/// <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);
}
