public AutoIdentityDAC(
IDAC decoratedDAC,
AutoIdentityPolicy autoIdentityPolicy = AutoIdentityPolicy.UseDBMSAutoIncrement,
PrimaryKeyConvention primaryKeyConvention = PrimaryKeyConvention.Default)
: base(decoratedDAC)
{
DefaultAutoIdentityPolicy = autoIdentityPolicy;
DefaultPrimaryKeyConvention = primaryKeyConvention;
}
protected NhibernateConfigurator(bool shouldMapDtos = true)
{
ShouldMapDtos = shouldMapDtos;
var assembliesToMap = GetAssembliesToMap();
var includeBaseTypes = GetIncludeBaseTypes();
var ignoreBaseTypes = GetIgnoreBaseTypes();
var discriminatedTypes = GetDiscriminatedTypes();
var mapDefaultConventions = ShouldMapDefaultConventions();
var assemblyWithAdditionalConventions = GetAssembliesWithAdditionalConventions();
_configuration = new Configuration();
_configuration.Configure();
var autoPersistenceModel = AutoMap.Assemblies(
new AutomappingConfiguration(discriminatedTypes.ToArray(), GetFuncToDetermineIfTypeIsDto(), ShouldMapDtos),
assembliesToMap
);
includeBaseTypes.Each(x => autoPersistenceModel.IncludeBase(x));
ignoreBaseTypes.Each(x => autoPersistenceModel.IgnoreBase(x));
assembliesToMap.Each(x => autoPersistenceModel.UseOverridesFromAssembly(x));
if (mapDefaultConventions)
{
DisableLazyLoadForDtosConvention.SetFuncToDetermineIfTypeIsDto(GetFuncToDetermineIfTypeIsDto());
HasManyForDomainConvention.SetPropertyNameToBackingFieldNameFunc(GetPropertyNameToBackingFieldNameFunc());
PrimaryKeyConvention.SetIdentityHiLoMaxLo(GetIdentityHiLoMaxLo());
autoPersistenceModel.Conventions.AddFromAssemblyOf <PrimaryKeyConvention>();
}
assemblyWithAdditionalConventions.Each(x => autoPersistenceModel.Conventions.AddAssembly(x));
if (ShouldDoubleQuoteTableNamesForDerivedClasses(_configuration))
{
_configuration.SetNamingStrategy(new QuoteTableNamesForDerivedClassesNamingStrategy());
}
var fluentConfiguration = Fluently.Configure(_configuration)
.Mappings(x =>
{
var mappingsContainer = x.AutoMappings.Add(autoPersistenceModel);
var exportNhibernateMappingsFolder = GetExportNhibernateMappingsFolder();
if (!string.IsNullOrWhiteSpace(exportNhibernateMappingsFolder))
{
mappingsContainer.ExportTo(exportNhibernateMappingsFolder);
}
});
_sessionFactory = fluentConfiguration.BuildSessionFactory();
}
/// <summary>
/// Main NHibernate configuration method.
/// It configures NHibernate in an opinionated way, with an option to override various small NHibernate settings by overriding
/// other virtual methods.
/// This method can be overridden to completely customize NHibernate configuration.
/// </summary>
/// <param name="shouldMapDtos">See the constructor</param>
/// <param name="configurationFileName">See the constructor</param>
/// <param name="connectionString">See the constructor</param>
/// <param name="sessionFactory">NHibernate session factory</param>
/// <param name="configuration">NHibernate configuration</param>
protected virtual void ConfigureNhibernate(
bool shouldMapDtos,
string configurationFileName,
string connectionString,
out ISessionFactory sessionFactory,
out Configuration configuration
)
{
configuration = new Configuration();
if (string.IsNullOrWhiteSpace(configurationFileName))
{
configuration.Configure();
}
else
{
configuration.Configure(configurationFileName);
}
var assembliesToMap = GetAssembliesToMap();
var isTypeDto = GetIsTypeDtoFunc();
var autoPersistenceModel = AutoMap.Assemblies(
GetAutomappingConfiguration(shouldMapDtos, isTypeDto),
assembliesToMap
);
GetIncludeBaseTypes().Each(x => autoPersistenceModel.IncludeBase(x));
GetIgnoreBaseTypes().Each(x => autoPersistenceModel.IgnoreBase(x));
assembliesToMap.Each(x => autoPersistenceModel.UseOverridesFromAssembly(x));
_configureConventions();
configuration.SetNamingStrategy(GetNamingStrategy());
var fluentConfiguration = Fluently.Configure(configuration)
.Mappings(x =>
{
var mappingsContainer = x.AutoMappings.Add(autoPersistenceModel);
var exportNhibernateMappingsPath = GetExportNhibernateMappingsPath();
if (!string.IsNullOrWhiteSpace(exportNhibernateMappingsPath))
{
mappingsContainer.ExportTo(exportNhibernateMappingsPath);
}
});
if (!string.IsNullOrWhiteSpace(connectionString))
{
configuration.SetProperty(Environment.ConnectionString, connectionString);
}
AdditionalConfiguration(configuration);
sessionFactory = fluentConfiguration.BuildSessionFactory();
void _configureConventions()
{
if (ShouldUseDefaultConventions())
{
DisableLazyLoadForDtosConvention.Initialize(isTypeDto);
HasManyConvention.Initialize(
GetCollectionCascadeInstanceAction(),
GetBackingFieldNameFromPropertyNameFunc(),
GetCollectionInstanceAccessAction()
);
PrimaryKeyConvention.Initialize(GetIdentityHiLoMaxLo());
var disabledConventions = GetDisabledConventions();
var conventionTypes = Assembly.GetExecutingAssembly().GetTypes()
.Where(type => typeof(IConvention).IsAssignableFrom(type) &&
!type.IsInterface &&
!disabledConventions.Contains(type))
.ToList();
conventionTypes.Each(conventionType => autoPersistenceModel.Conventions.Add(conventionType));
}
GetAssembliesWithAdditionalConventions().Each(assembly => autoPersistenceModel.Conventions.AddAssembly(assembly));
GetAdditionalConventions().Each(conventionType => autoPersistenceModel.Conventions.Add(conventionType));
}
}
public void CreateConvention()
{
convention = new PrimaryKeyConvention();
}
