성 ActiveRecord Save()가 업데이트되지만 생성되지 않습니다.

Question

저는 프로그램을 업데이트하고 데이터베이스에 새 테이블을 추가하려고합니다. 이 프로그램은 Castle의 ActiveRecord와 저장소를 사용합니다. 클래스와 저장소를 설정하고 데이터베이스 케이스에서 테스트 케이스를 얻을 수 있습니다. 그러나 데이터베이스에 새 레코드를 추가하려고하면 아무 일도 일어나지 않습니다. 오류가없고 새로운 기록이 없습니다. 테스트 케이스를 데이터베이스에서 꺼내서 뭔가를 변경 한 다음 Save()를 호출하면 데이터베이스의 레코드가 변경됩니다.

이

내가 테스트에 사용하고 코드입니다 : 지금은 중지하고 성 프레임 워크는 모든 일을하는 방법을 연구하는 진짜 시간과 maintenence의 프로젝트로

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 
} 

Answer 1

당신을 보인다 명시 적, 국가 PK를 설정하는 경우 당신은 아마도 Save() 대신 Create()를 호출 할 필요가있을 것이다. (당신의 저장소 구현이 이것을 공개하는지 모르겠다.)

이것이 작동하지 않으면 클래스 매핑과 저장소 구현을 게시하십시오.