private MappingManager(IMappingLoader Loader)
{
if (Loader == null)
{
throw new MappingException("Loader不能为空");
}
m_Loader = Loader;
}
private void Initialize(IMappingLoader loader)
{
factory.Initialize(loader);
foreach (KeyValuePair <System.Type, IClassValidator> validator in factory.Validators)
{
AddValidatableElement(new ValidatableElement(validator.Key, validator.Value));
}
}
/// <summary>
/// 获取管理对象
/// </summary>
/// <param name="Loader"></param>
/// <returns></returns>
public static MappingManager GetMappingManager(IMappingLoader Loader)
{
if (m_obj == null)
{
m_obj = new MappingManager(Loader);
}
return(m_obj);
}
public override void SetUp()
{
base.SetUp();
_emptyClassDefinitions = new ClassDefinition[0];
_emptyRelationDefinitions = new RelationDefinition[0];
_memberInformationNameResolver = new ReflectionBasedMemberInformationNameResolver();
_mockRepository = new MockRepository();
_mockMappingLoader = _mockRepository.StrictMock <IMappingLoader>();
_fakeStorageEntityDefinition = TableDefinitionObjectMother.Create(
DomainObjectsConfiguration.Current.Storage.DefaultStorageProviderDefinition, new EntityNameDefinition(null, "Test"));
}
public void Initialize(IMappingLoader loader)
{
try
{
var sfcmf = new StateFullClassMappingFactory();
classMappingFactory = sfcmf;
var definitions = loader.GetMappings();
foreach (var classMapping in definitions)
{
sfcmf.AddClassExternalDefinition(classMapping);
}
foreach (System.Type type in sfcmf.GetLoadedDefinitions())
{
GetRootValidator(type);
}
}
finally
{
classMappingFactory = defaultClassMappingFactory;
}
}
public void Initialize(IMappingLoader loader)
{
try
{
var sfcmf = new StateFullClassMappingFactory();
classMappingFactory = sfcmf;
var definitions = loader.GetMappings();
foreach (var classMapping in definitions)
{
sfcmf.AddClassExternalDefinition(classMapping);
}
foreach (System.Type type in sfcmf.GetLoadedDefinitions())
{
GetRootValidator(type);
}
}
finally
{
classMappingFactory = defaultClassMappingFactory;
}
}
// construction and disposing
public MappingConfiguration(IMappingLoader mappingLoader, IPersistenceModelLoader persistenceModelLoader)
{
ArgumentUtility.CheckNotNull("mappingLoader", mappingLoader);
ArgumentUtility.CheckNotNull("persistenceModelLoader", persistenceModelLoader);
s_log.Info("Building mapping configuration...");
using (StopwatchScope.CreateScope(s_log, LogLevel.Info, "Time needed to build and validate mapping configuration: {elapsed}."))
{
var mappingConfigurationValidationHelper = new MappingConfigurationValidationHelper(mappingLoader, persistenceModelLoader);
var typeDefinitions = mappingLoader.GetClassDefinitions();
_typeDefinitions = new ReadOnlyDictionary <Type, ClassDefinition> (typeDefinitions.ToDictionary(td => td.ClassType));
mappingConfigurationValidationHelper.ValidateDuplicateClassIDs(typeDefinitions.OfType <ClassDefinition>());
_classDefinitions = new ReadOnlyDictionary <string, ClassDefinition> (typeDefinitions.ToDictionary(cd => cd.ID));
mappingConfigurationValidationHelper.ValidateClassDefinitions(_typeDefinitions.Values);
mappingConfigurationValidationHelper.ValidatePropertyDefinitions(_typeDefinitions.Values);
var relationDefinitions = mappingLoader.GetRelationDefinitions(_typeDefinitions);
_relationDefinitions = new ReadOnlyDictionary <string, RelationDefinition> (relationDefinitions.ToDictionary(rd => rd.ID));
mappingConfigurationValidationHelper.ValidateRelationDefinitions(_relationDefinitions.Values);
foreach (var rootClass in GetInheritanceRootClasses(_typeDefinitions.Values))
{
persistenceModelLoader.ApplyPersistenceModelToHierarchy(rootClass);
mappingConfigurationValidationHelper.VerifyPersistenceModelApplied(rootClass);
mappingConfigurationValidationHelper.ValidatePersistenceMapping(rootClass);
}
_resolveTypes = mappingLoader.ResolveTypes;
_nameResolver = mappingLoader.NameResolver;
SetMappingReadOnly();
mappingConfigurationValidationHelper.ValidateSortExpression(_relationDefinitions.Values);
}
}
/// <summary>
/// Configure NHibernate.Validator using the specified <see cref="INHVConfiguration"/>.
/// </summary>
/// <param name="config">The <see cref="INHVConfiguration"/> that is the configuration reader to configure NHibernate.Validator.</param>
/// <param name="mappingLoader">The <see cref="XmlMappingLoader"/> instance.</param>
/// <remarks>
/// Calling Configure(INHVConfiguration) will overwrite the values set in app.config or web.config
/// </remarks>
public virtual void Configure(INHVConfiguration config, IMappingLoader mappingLoader)
{
if (config == null)
{
throw new ValidatorConfigurationException("Could not configure NHibernate.Validator.",
new ArgumentNullException("config"));
}
Clear();
applyToDDL = PropertiesHelper.GetBoolean(Environment.ApplyToDDL, config.Properties, true);
autoRegisterListeners = PropertiesHelper.GetBoolean(Environment.AutoregisterListeners, config.Properties, true);
defaultMode =
CfgXmlHelper.ValidatorModeConvertFrom(PropertiesHelper.GetString(Environment.ValidatorMode, config.Properties,
string.Empty));
interpolator =
GetImplementation <IMessageInterpolator>(
PropertiesHelper.GetString(Environment.MessageInterpolatorClass, config.Properties, string.Empty),
"message interpolator");
if (Environment.ConstraintValidatorFactory == null)
{
constraintValidatorFactory = GetImplementation <IConstraintValidatorFactory>(
PropertiesHelper.GetString(Environment.ConstraintValidatorFactoryClass,
config.Properties,
string.Empty),
"Constraint Validator Factory") ?? new DefaultConstraintValidatorFactory();
}
else
{
constraintValidatorFactory = Environment.ConstraintValidatorFactory;
}
var inspectorsTypes = new HashSet <System.Type>(config.EntityTypeInspectors)
{
typeof(DefaultEntityTypeInspector)
};
if (inspectorsTypes.Count > 1)
{
var inspectors = config.EntityTypeInspectors.Select(typeInspector => Instatiate <IEntityTypeInspector>(typeInspector)).ToArray();
entityTypeInspector = new MultiEntityTypeInspector(inspectors);
}
else
{
entityTypeInspector = new DefaultEntityTypeInspector();
}
ResourceManager customResourceManager = null;
var customResourceManagerBaseName = PropertiesHelper.GetString(Environment.CustomResourceManager, config.Properties,
null);
if (!string.IsNullOrEmpty(customResourceManagerBaseName))
{
var resourceAndAssembly = TypeNameParser.Parse(customResourceManagerBaseName);
try
{
var assembly = Assembly.Load(resourceAndAssembly.Assembly);
customResourceManager = new ResourceManager(resourceAndAssembly.Type, assembly);
}
catch (Exception e)
{
throw new ValidatorConfigurationException("Could not configure NHibernate.Validator (custom resource manager).", e);
}
}
factory = new StateFullClassValidatorFactory(constraintValidatorFactory, customResourceManager, null, interpolator, defaultMode,
entityTypeInspector);
// UpLoad Mappings
if (mappingLoader == null)
{
// Configured or Default loader (XmlMappingLoader)
mappingLoader = GetImplementation <IMappingLoader>(
PropertiesHelper.GetString(Environment.MappingLoaderClass, config.Properties, string.Empty),
"mapping loader") ?? new XmlMappingLoader();
}
mappingLoader.LoadMappings(config.Mappings);
Initialize(mappingLoader);
}
public new void SetUp()
{
base.SetUp();
_mappingReflector = MappingReflectorObjectMother.CreateMappingReflector(TestMappingConfiguration.GetTypeDiscoveryService());
}
