/// <summary> /// Gets the model properties metadata. /// </summary> /// <param name="modelType">Type of the model.</param> /// <returns></returns> public virtual IDictionary <string, ModelMetadataItem> GetModelPropertiesMetadata(Type modelType) { Invariant.IsNotNull(modelType, "modelType"); ModelMetadataRegistryItem item = GetModelMetadataRegistryItem(modelType); return(item == null ? null : item.PropertiesMetadata); }
/// <summary> /// Registers the model type metadata. /// </summary> /// <param name="modelType">Type of the model.</param> /// <param name="metadataItem">The metadata.</param> public virtual void RegisterModel(Type modelType, ModelMetadataItem metadataItem) { Invariant.IsNotNull(modelType, "modelType"); Invariant.IsNotNull(metadataItem, "metadataItem"); ModelMetadataRegistryItem item = GetOrCreate(modelType); item.ClassMetadata = metadataItem; }
private ModelMetadataRegistryItem CreateModelMetadataRegistryItem([NotNull] Type modelType) { Invariant.IsNotNull(modelType, "modelType"); IModelMetadataConfiguration configuration; if (!configurations.TryGetValue(modelType, out configuration)) { configuration = configurations .Where(kvp => kvp.Key.IsAssignableFrom(modelType)) .OrderBy(x => x.Key, new TypeInheritanceComparer()) .Select(x => x.Value) .FirstOrDefault(); } var canAcceptConventions = ConventionAcceptor.CanAcceptConventions(new AcceptorContext(modelType, configuration != null)); if (configuration == null && !canAcceptConventions) { return(null); } var item = new ModelMetadataRegistryItem(); if (canAcceptConventions) { var properties = modelType.GetProperties(); foreach (var convention in conventions) { foreach (var pi in properties) { if (convention.IsApplicable(pi)) { var propertyMetadata = item.GetPropertyMetadataOrCreateNew(pi.Name); convention.Apply(pi, propertyMetadata); } } } } if (configuration != null) { foreach (var pair in configuration.Configurations) { var name = pair.Key; var configurator = pair.Value; var propertyMetadata = item.GetPropertyMetadataOrCreateNew(name); configurator.Configure(propertyMetadata); } } return(item); }
private ModelMetadataRegistryItem GetOrCreate(Type modelType) { ModelMetadataRegistryItem item; if (!mappings.TryGetValue(modelType, out item)) { item = new ModelMetadataRegistryItem(); mappings.Add(modelType, item); } return(item); }
/// <summary> /// Registers the specified model type properties metadata. /// </summary> /// <param name="modelType">Type of the model.</param> /// <param name="metadataItems">The metadata dictionary.</param> public virtual void RegisterModelProperties(Type modelType, IDictionary <string, ModelMetadataItem> metadataItems) { Invariant.IsNotNull(modelType, "modelType"); Invariant.IsNotNull(metadataItems, "metadataItems"); ModelMetadataRegistryItem item = GetOrCreate(modelType); item.PropertiesMetadata.Clear(); foreach (KeyValuePair <string, ModelMetadataItem> pair in metadataItems) { item.PropertiesMetadata.Add(pair.Key, pair.Value); } }
private void ProcessUnacceptedModelType(Type modelType, ModelMetadataRegistryItem item) { if (item == null) { // mark item as ignored if (!ignoredClassesCache.Contains(modelType)) { ignoredClassesCache.Add(modelType); } } else { // if we have some metadata item, // just mark it as processed and do not add any conventions item.IsConventionsApplied = true; } }
/// <summary> /// Gets the model property metadata. /// </summary> /// <param name="modelType">Type of the model.</param> /// <param name="propertyName">Name of the property.</param> /// <returns></returns> public virtual ModelMetadataItem GetModelPropertyMetadata(Type modelType, string propertyName) { Invariant.IsNotNull(modelType, "modelType"); ModelMetadataRegistryItem item = GetModelMetadataRegistryItem(modelType); if (item == null) { return(null); } ModelMetadataItem propertyMetadata; return(item.PropertiesMetadata.TryGetValue(propertyName, out propertyMetadata) ? propertyMetadata : null); }
private void ApplyMetadataConvenstions([NotNull] Type modelType, [NotNull] ModelMetadataRegistryItem item) { var properties = modelType.GetProperties(); foreach (var convention in conventions) { var metadataConvention = convention; foreach (var pi in properties.Where(metadataConvention.IsApplicable)) { ModelMetadataItem metadataItem; if (!item.PropertiesMetadata.TryGetValue(pi.Name, out metadataItem)) { metadataItem = new ModelMetadataItem(); item.PropertiesMetadata.Add(pi.Name, metadataItem); } var conventionalItem = new ModelMetadataItem(); convention.Apply(pi, conventionalItem); conventionalItem.MergeTo(metadataItem); } } item.IsConventionsApplied = true; }
private bool NoNeedToApplyConvetionsFor(Type modelType, ModelMetadataRegistryItem item) { return(item == null && ignoredClassesCache.Contains(modelType) || item != null && item.IsConventionsApplied); }
private ModelMetadataRegistryItem CheckMetadataAndApplyConvetions([NotNull] Type modelType, ModelMetadataRegistryItem item) { if (conventions.Count == 0 || NoNeedToApplyConvetionsFor(modelType, item)) { return(item); } lock (this) { if (NoNeedToApplyConvetionsFor(modelType, item)) { return(item); } ModelMetadataRegistryItem registeredItem; // ensure that conventions were not appied by another thread if (mappings.TryGetValue(modelType, out registeredItem) && registeredItem.IsConventionsApplied) { return(registeredItem); } var context = new AcceptorContext(modelType, item != null); var canAcceptConventions = ConventionAcceptor.CanAcceptConventions(context); if (!canAcceptConventions) { ProcessUnacceptedModelType(modelType, item); return(item); } if (item == null) { // try get existing (item can be created by another thread) or create new item = GetOrCreate(modelType); } // ensure convenstion is not applied yet if (item.IsConventionsApplied) { return(item); } ApplyMetadataConvenstions(modelType, item); } return(item); }