C# 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);

现在，由于这是一个维护项目，没有实时停下来研究Castle框架是如何完成所有工作的，所以我边做边学习。我通过研究代码的其余部分学习了如何操作，并且在代码中有一些情况下，上面的代码已用于创建新记录，因此我确信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; }
    }
}

[ActiveRecord（“国家”）]
[搜索实体]
公共类国家：抽象实体
{
国际国家ID；
字符串\u名称；
国际行动；
[PrimaryKey（“CountryId”）]
公共整数Id
{
获取{return\u countryId；}
设置{u countryId=value；}
}
[搜索属性]
[属性（长度=100）]
公共字符串名
{
获取{return\u name；}
设置{u name=value；}
}
[物业]
public int PostRegisterActionId
{
获取{return\u action；}
设置{u 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
}

[瞬态]
公共抽象类AbstractRepository:IRepository，其中T:AbstractEntity，new（）
{
#区域私人VAR
受保护的未来查询引擎(FutureQueryRunner);；
受保护的IDynamicSearchService（动态搜索服务）；
受保护的bool\u缓存；
受保护的int_缓存页；
受保护的CachingFutureQueryOfList\u cachedQuery；
受保护的IServiceBus\u服务总线；
私有字符串_entityTypeName=string.Empty；
#端区
#区域构造函数
公共抽象存储库（IDynamicSearchService dynamicSearchService，IServiceBus serviceBus）
{
_dynamicSearchService=dynamicSearchService；
_serviceBus=serviceBus；
}
#端区
#区域公共方法
公共虚拟空保存（T实例）
{
ActiveRecordMediator.Save（实例）；
}
公共虚拟void创建（T实例）
{
ActiveRecordMediator.Create（实例）；
}
公共无效删除（T实例）
{
ActiveRecordMediator.Delete（实例）；
}
新建（）的公共虚拟IFutureQueryOf
{
返回新的NullFutureQuery（）；
}
FindById的公共虚拟IFutureQueryOf（int-id/*，params-string[]eanger-associations*/）//eanger-associations错误
{
DetachedCriteria=GetDefaultCriteria（）
.Add（Expression.IdEq（id））；
/*foreach（字符串插入）
criteria.SetFetchMode（eager，NHibernate.FetchMode.eager）*/
返回新的FutureQueryOf（_futureQueryRunner）
.SetCriteria（标准）；
}
公共虚拟IFutureQueryOfList FindAll（字符串排序，布尔排序）
{
DetachedCriteria=GetDefaultCriteria（）；
如果（！string.IsNullOrEmpty（sortBy））
criteria.AddOrder（sortAsc？NHibernate.criteria.Order.Asc（sortBy）：NHibernate.criteria.Order.Desc（sortBy））；
返回新的FutureQueryFlist（_futureQueryRunner）
.SetCriteria（标准）；
}
公共虚拟IFutureQueryOfList FindAll（int-page，int-resultsPerPage，string-sortBy，bool-sortAsc）
{
返回FindAll（新的DefaultCriteriaProvider（DetachedCriteria.For（）），
页
结果每页，
糟糕的是，
sortAsc，
“芬达尔”）；
}
公共虚拟IFutureQueryOfList FindAll（字符串搜索字符串、整型页面、整型结果每页、字符串排序、布尔排序）
{
返回FindAll（新的SearchStringCriteriaProvider（_dynamicSearchService，searchString），
页
结果每页，
糟糕的是，
sortAsc，
“FindAllSearchString_uz”+搜索字符串）；
}
公共虚拟IFutureQueryOfList FindAll（IListFilter筛选器、int页、int resultsPerPage、字符串排序、bool排序）
{
返回FindAll（新的FilterCriteriaProvider（\u dynamicSearchService，filter），
页
结果每页，
糟糕的是，
sortAsc，
“FindAllistFilter”）；//TODO-缓存键需要表示单个筛选器
}
GetCount的公共虚拟IFutureQueryOf（字符串搜索字符串）
{
返回新的FutureQueryOf（_futureQueryRunner）
.SetCriteria（AddDefaultCriteria（新的SearchStringCriteriaProvider）（\u dynamicSearchService，searchString）.GetDetachedCriteria（））
.SetProjection（Projections.RowCount（））；
}
GetCount（）的公共虚拟IFutureQueryOf
{
返回新的FutureQueryOf（_futureQueryRunner）
.SetCriteria（GetDefaultCriteria（）
.SetProjection（Projections.RowCount（））；
}
公共虚拟字符串EntityType
{
得到
{
if（string.IsNullOrEmpty（_entityTypeName））
_entityTypeName=typeof（T）.Name；
返回_entityTypeName；
}
}
公共IRepository EnableCaching（布尔缓存）
{
_缓存=缓存；
归还这个；
}
公共IRepository with pagestoc