internal static ClassData Read(XmlReader xmlReader)
{
var classData = new ClassData();
xmlReader.MoveToFirstAttribute();
do
{
if (xmlReader.Name.Length > 0)
{
switch (xmlReader.Name)
{
case ("typeName"):
{
classData.TypeName = xmlReader.Value;
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}
}
} while (xmlReader.MoveToNextAttribute());
while (xmlReader.Read())
{
if (xmlReader.NodeType == XmlNodeType.EndElement)
{
break;
}
if (xmlReader.IsStartElement())
{
switch (xmlReader.Name)
{
case("method"):
{
var methodData = MethodData.Read(xmlReader);
classData.Methods.Add(methodData);
break;
}
case("property"):
{
var propertyData = PropertyData.Read(xmlReader);
classData.Properties.Add(propertyData);
break;
}
case("field"):
{
var fieldData = FieldData.Read(xmlReader);
classData.Fields.Add(fieldData);
break;
}
default:
{
throw new Exception(string.Format("Un-expected element while parsing xml. Element name='{0}'", xmlReader.Name));
}
}}
}
xmlReader.Read();
return classData;
}
private static void ProcessFields(ClassData classData, Type classType)
{
if ((classData.Fields != null) && (classData.Fields.Count > 0))
{
//var runtimeTypeHandle = classType.TypeHandle;
var typeDescriptor = TypeCache.GetType(classType);
for (var fieldIndex = 0; fieldIndex < classData.Fields.Count; fieldIndex++)
{
var fieldData = classData.Fields[fieldIndex];
FieldDescriptor fieldDescriptor;
if (!typeDescriptor.Fields.TryGetValue(fieldData.Name, out fieldDescriptor))
{
fieldDescriptor = typeDescriptor.GetOrCreateFieldDescriptor(fieldData.Name);
}
AddRuleToInfoDescriptor(fieldData.RuleDatas, fieldDescriptor);
}
}
}
private static void ProcessProperties(ClassData classData, Type classType)
{
if ((classData.Properties != null) && (classData.Properties.Count > 0))
{
//var runtimeTypeHandle = classType.TypeHandle;
var typeDescriptor = TypeCache.GetType(classType);
for (var propertyIndex = 0; propertyIndex < classData.Properties.Count; propertyIndex++)
{
var propertyData = classData.Properties[propertyIndex];
PropertyDescriptor propertyDescriptor;
if (!typeDescriptor.Properties.TryGetValue(propertyData.Name, out propertyDescriptor))
{
propertyDescriptor = typeDescriptor.GetOrCreatePropertyDescriptor(propertyData.Name);
}
AddRuleToInfoDescriptor(propertyData.RuleDatas, propertyDescriptor);
}
}
}
private static void ProcessMethods(ClassData classData, Type classType)
{
if ((classData.Methods != null) && (classData.Methods.Count > 0))
{
for (var methodIndex = 0; methodIndex < classData.Methods.Count; methodIndex++)
{
var methodData = classData.Methods[methodIndex];
MethodInfo methodInfo;
if (methodData.OverloadTypes.Count == 0)
{
methodInfo = classType.GetMethod(methodData.Name);
}
else
{
var types = new Type[methodData.OverloadTypes.Count];
for (var overloadTypeIndex = 0; overloadTypeIndex < methodData.OverloadTypes.Count; overloadTypeIndex++)
{
var typeData = methodData.OverloadTypes[overloadTypeIndex];
types[overloadTypeIndex] = Type.GetType(typeData.TypeName, true);
}
methodInfo = classType.GetMethod(methodData.Name, types);
}
var methodDescriptor = MethodCache.GetMethod(methodInfo.MethodHandle);
for (var parameterIndex = 0; parameterIndex < methodData.Parameters.Count; parameterIndex++)
{
var parameterData = methodData.Parameters[parameterIndex];
var parameterDescriptor = methodDescriptor.Parameters[parameterData.Name];
AddRuleToInfoDescriptor(parameterData.RuleDatas, parameterDescriptor);
}
}
}
}
