1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Web.Mvc.Properties;
namespace System.Web.Mvc
{
// This class provides a good implementation of ModelMetadataProvider for people who will be
// using traditional classes with properties. It uses the buddy class support from
// DataAnnotations, and consolidates the three operations down to a single override
// for reading the attribute values and creating the metadata class.
public abstract class AssociatedMetadataProvider : ModelMetadataProvider
{
private static void ApplyMetadataAwareAttributes(IEnumerable<Attribute> attributes, ModelMetadata result)
{
foreach (IMetadataAware awareAttribute in attributes.OfType<IMetadataAware>())
{
awareAttribute.OnMetadataCreated(result);
}
}
protected abstract ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName);
protected virtual IEnumerable<Attribute> FilterAttributes(Type containerType, PropertyDescriptor propertyDescriptor, IEnumerable<Attribute> attributes)
{
if (typeof(ViewPage).IsAssignableFrom(containerType) || typeof(ViewUserControl).IsAssignableFrom(containerType))
{
return attributes.Where(a => !(a is ReadOnlyAttribute));
}
return attributes;
}
public override IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType)
{
if (containerType == null)
{
throw new ArgumentNullException("containerType");
}
return GetMetadataForPropertiesImpl(container, containerType);
}
private IEnumerable<ModelMetadata> GetMetadataForPropertiesImpl(object container, Type containerType)
{
foreach (PropertyDescriptor property in GetTypeDescriptor(containerType).GetProperties())
{
Func<object> modelAccessor = container == null ? null : GetPropertyValueAccessor(container, property);
yield return GetMetadataForProperty(modelAccessor, containerType, property);
}
}
public override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName)
{
if (containerType == null)
{
throw new ArgumentNullException("containerType");
}
if (String.IsNullOrEmpty(propertyName))
{
throw new ArgumentException(MvcResources.Common_NullOrEmpty, "propertyName");
}
ICustomTypeDescriptor typeDescriptor = GetTypeDescriptor(containerType);
PropertyDescriptor property = typeDescriptor.GetProperties().Find(propertyName, true);
if (property == null)
{
throw new ArgumentException(
String.Format(
CultureInfo.CurrentCulture,
MvcResources.Common_PropertyNotFound,
containerType.FullName, propertyName));
}
return GetMetadataForProperty(modelAccessor, containerType, property);
}
protected virtual ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, PropertyDescriptor propertyDescriptor)
{
IEnumerable<Attribute> attributes = FilterAttributes(containerType, propertyDescriptor, propertyDescriptor.Attributes.Cast<Attribute>());
ModelMetadata result = CreateMetadata(attributes, containerType, modelAccessor, propertyDescriptor.PropertyType, propertyDescriptor.Name);
ApplyMetadataAwareAttributes(attributes, result);
return result;
}
public override ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType)
{
if (modelType == null)
{
throw new ArgumentNullException("modelType");
}
IEnumerable<Attribute> attributes = GetTypeDescriptor(modelType).GetAttributes().Cast<Attribute>();
ModelMetadata result = CreateMetadata(attributes, null /* containerType */, modelAccessor, modelType, null /* propertyName */);
ApplyMetadataAwareAttributes(attributes, result);
return result;
}
private static Func<object> GetPropertyValueAccessor(object container, PropertyDescriptor property)
{
return () => property.GetValue(container);
}
protected virtual ICustomTypeDescriptor GetTypeDescriptor(Type type)
{
return TypeDescriptorHelper.Get(type);
}
}
}
|
