castle activerecord save()将更新,但不会创建

我正在更新程序并向数据库添加新表。该程序使用Castle的ActiveRecord和存储库。我已经设置了类和存储库,可以很好地从数据库中获取测试用例。但是,当我尝试向数据库添加新记录时,什么也不会发生。没有错误,也没有新记录。如果我将测试用例从数据库中取出并更改某些内容,然后调用save(),数据库中的记录将更改。

这是我用来测试的代码:

ICountryRepository _countryRepository = Country.GetRepository(site.Id);

//get test case and update
Country c = _countryRepository.FindById(1).Value;
c.Name = "c";
_countryRepository.Save(c);

//create new Country and save
Country d = new Country();
d.Id = 2;
d.Name = "d";
_countryRepository.Save(d);

现在,由于这是一个没有实时停止和研究城堡框架是如何做每件事的维护项目,我正在学习。我已经学习了如何通过研究代码的其余部分来完成任务,并且在代码中有时会使用上面的代码来创建新的记录,所以我确信save()是正确的调用函数。

我尝试将创建代码与代码的另一部分一起放入,该部分代码将对象插入到另一个表中,只是为了确保游戏中没有不同级别的权限。在数据库中,我添加的表和基于代码的表之间没有区别。

正如我所说,我在ActiveRecord和Castle框架方面的经验很少,它可能会非常简单。希望有人能告诉我。

谢谢。

编辑:

国家等级:

[ActiveRecord("Country")]
[SearchEntity]
public class Country : AbstractEntity<Country, ICountryRepository>
{
    int _countryId;
    string _name;
    int _action;

    [PrimaryKey("CountryId")]
    public int Id
    {
        get { return _countryId; }
        set { _countryId = value; }
    }

    [SearchProperty]
    [Property(Length = 100)]
    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    [Property]
    public int PostRegisterActionId
    {
        get { return _action; }
        set { _action = value; }
    }
}

AbstractRepository,因为CountryRepository目前不做任何操作:

[Transient]
public abstract class AbstractRepository<T> : IRepository<T> where T : AbstractEntity, new()
{
    #region Private Vars
    protected FutureQueryRunner _futureQueryRunner;
    protected IDynamicSearchService _dynamicSearchService;
    protected bool _caching;
    protected int _cachedPages;
    protected CachingFutureQueryOfList<T> _cachedQuery;
    protected IServiceBus _serviceBus;
    private string _entityTypeName = string.Empty;
    #endregion

    #region Constructors
    public AbstractRepository(IDynamicSearchService dynamicSearchService, IServiceBus serviceBus)
    {
        _dynamicSearchService = dynamicSearchService;
        _serviceBus = serviceBus;
    }
    #endregion

    #region Public Methods
    public virtual void Save(T instance)
    {
        ActiveRecordMediator<T>.Save(instance);
    }

    public virtual void Create(T instance)
    {
        ActiveRecordMediator<T>.Create(instance);
    }

    public void Delete(T instance)
    {
        ActiveRecordMediator<T>.Delete(instance);
    }

    public virtual IFutureQueryOf<T> New()
    {
        return new NullFutureQuery<T>();
    }

    public virtual IFutureQueryOf<T> FindById(int id/*, params string[] eagerAssociations*/) // eager associations buggy
    {
        DetachedCriteria criteria = GetDefaultCriteria()
                .Add(Expression.IdEq(id));

        /*foreach (string eager in eagerAssociations)
            criteria.SetFetchMode(eager, NHibernate.FetchMode.Eager);*/

        return new FutureQueryOf<T>(_futureQueryRunner)
            .SetCriteria(criteria);
    }

    public virtual IFutureQueryOfList<T> FindAll(string sortBy, bool sortAsc)
    {
        DetachedCriteria criteria = GetDefaultCriteria();

        if (!string.IsNullOrEmpty(sortBy))
            criteria.AddOrder(sortAsc ? NHibernate.Criterion.Order.Asc(sortBy) : NHibernate.Criterion.Order.Desc(sortBy));

        return new FutureQueryOfList<T>(_futureQueryRunner)
            .SetCriteria(criteria);
    }

    public virtual IFutureQueryOfList<T> FindAll(int page, int resultsPerPage, string sortBy, bool sortAsc)
    {
        return FindAll(new DefaultCriteriaProvider<T>(DetachedCriteria.For<T>()),
            page,
            resultsPerPage,
            sortBy,
            sortAsc,
            "FindAll");
    }

    public virtual IFutureQueryOfList<T> FindAll(string searchString, int page, int resultsPerPage, string sortBy, bool sortAsc)
    {
        return FindAll(new SearchStringCriteriaProvider<T>(_dynamicSearchService, searchString),
            page,
            resultsPerPage,
            sortBy,
            sortAsc,
            "FindAllSearchString_" + searchString);
    }

    public virtual IFutureQueryOfList<T> FindAll(IListFilter filter, int page, int resultsPerPage, string sortBy, bool sortAsc)
    {
        return FindAll(new FilterCriteriaProvider<T>(_dynamicSearchService, filter),
            page,
            resultsPerPage,
            sortBy,
            sortAsc,
            "FindAllListFilter"); // TODO - the cache key needs to represent individual filters
    }

    public virtual IFutureQueryOf<int> GetCount(string searchString)
    {
        return new FutureQueryOf<int>(_futureQueryRunner)
            .SetCriteria(AddDefaultCriteria(new SearchStringCriteriaProvider<T>(_dynamicSearchService, searchString).GetDetachedCriteria())
                .SetProjection(Projections.RowCount()));
    }

    public virtual IFutureQueryOf<int> GetCount()
    {
        return new FutureQueryOf<int>(_futureQueryRunner)
            .SetCriteria(GetDefaultCriteria()
                .SetProjection(Projections.RowCount()));
    }

    public virtual string EntityType
    {
        get
        {
            if (string.IsNullOrEmpty(_entityTypeName))
                _entityTypeName = typeof(T).Name;
            return _entityTypeName;
        }
    }

    public IRepository<T> EnableCaching(bool caching)
    {
        _caching = caching;
        return this;
    }

    public IRepository<T> WithPagesToCache(int cachedPages)
    {
        _cachedPages = cachedPages;
        return this;
    }

    public virtual IRepository<T> ForSite(int siteId)
    {
        return this;
    }

    public IRepository<T> RunFutureQueriesWith(FutureQueryRunner futureQueryRunner)
    {
        _futureQueryRunner = futureQueryRunner;
        return this;
    }
    #endregion

    #region Protected Methods
    protected virtual DetachedCriteria AddDefaultCriteria(DetachedCriteria criteria)
    {
        return criteria;
    }
    protected DetachedCriteria GetDefaultCriteria()
    {
        return AddDefaultCriteria(DetachedCriteria.For<T>());
    }
    protected IFutureQueryOf<U> NewQueryOf<U>(DetachedCriteria criteria)
    {
        return new FutureQueryOf<U>(_futureQueryRunner).SetCriteria(criteria);
    }
    protected IFutureQueryOfList<U> NewQueryOfList<U>(DetachedCriteria criteria)
    {
        return new FutureQueryOfList<U>(_futureQueryRunner).SetCriteria(criteria);
    }
    #endregion

    #region Private Methods
    private IFutureQueryOfList<T> FindAll(ICriteriaProvider<T> criteriaProvider, int page, int resultsPerPage, string sortBy, bool sortAsc, string cacheKey)
    {
        CachingFutureQueryOfList<T> rtnVal = null;
        bool cached = false;
        if (_cachedQuery != null && _caching)
        {
            rtnVal = _cachedQuery;
            cached = rtnVal.SetPage(page, sortBy, sortAsc, cacheKey);
        }
        if (!cached)
        {
            rtnVal = new CachingFutureQueryOfList<T>(_futureQueryRunner, page, _cachedPages, resultsPerPage, cacheKey)
                .SetCriteria(AddDefaultCriteria(criteriaProvider.GetDetachedCriteria()), sortBy, sortAsc);

            if (_caching)
                _cachedQuery = rtnVal;
        }
        return rtnVal;
    }
    #endregion

    #region Criteria Providers
    private interface ICriteriaProvider<U>
    {
        DetachedCriteria GetDetachedCriteria();
    }

    private class DefaultCriteriaProvider<U> : ICriteriaProvider<U>
    {
        private DetachedCriteria _criteria;
        public DefaultCriteriaProvider(DetachedCriteria criteria)
        {
            _criteria = criteria;
        }
        public DetachedCriteria GetDetachedCriteria()
        {
            return _criteria;
        }
    }

    private class SearchStringCriteriaProvider<U> : ICriteriaProvider<U>
    {
        private IDynamicSearchService _searchService;
        private string _searchString;
        public SearchStringCriteriaProvider(IDynamicSearchService searchService, string searchString)
        {
            _searchService = searchService;
            _searchString = searchString;
        }
        public DetachedCriteria GetDetachedCriteria()
        {
            return _searchService.GetDetachedCriteria<U>(_searchString);
        }
    }

    private class FilterCriteriaProvider<U> : ICriteriaProvider<U>
    {
        private IDynamicSearchService _searchService;
        private IListFilter _filter;
        public FilterCriteriaProvider(IDynamicSearchService searchService, IListFilter filter)
        {
            _searchService = searchService;
            _filter = filter;
        }
        public DetachedCriteria GetDetachedCriteria()
        {
            return _searchService.GetDetachedCriteria<U>(_filter);
        }
    }
    #endregion
}