public MethodMetadata MapToDeserialize(MethodMetadataBase metadata)
{
MethodMetadata methodMetadata = new MethodMetadata
{
Name = metadata.Name,
Extension = metadata.Extension
};
Type type = metadata.GetType();
PropertyInfo genericArgumentsProperty = type.GetProperty("GenericArguments", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (genericArgumentsProperty?.GetValue(metadata) != null)
{
List <TypeMetadataBase> genericArguments = (List <TypeMetadataBase>)ConvertionUtilities.ConvertList(typeof(TypeMetadataBase), (IList)genericArgumentsProperty?.GetValue(metadata));
methodMetadata.GenericArguments = genericArguments.Select(g => TypeMetadataMapper.EmitTypeForDeserialization(g)).ToList();
}
methodMetadata.Modifiers = metadata.Modifiers;
PropertyInfo parametersProperty = type.GetProperty("Parameters", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
if (parametersProperty?.GetValue(metadata) != null)
{
List <ParameterMetadataBase> parameters = (List <ParameterMetadataBase>)ConvertionUtilities.ConvertList(typeof(ParameterMetadataBase), (IList)parametersProperty?.GetValue(metadata));
methodMetadata.Parameters = parameters.Select(p => new ParameterMetadataMapper().MapToDeserialize(p)).ToList();
}
PropertyInfo returnTypeProperty = type.GetProperty("ReturnType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
TypeMetadataBase returnType = (TypeMetadataBase)returnTypeProperty?.GetValue(metadata);
if (returnType != null)
{
methodMetadata.ReturnType = TypeMetadataMapper.EmitTypeForDeserialization(returnType);
}
return(methodMetadata);
}
public NamespaceMetadata MapToDeserialize(NamespaceMetadataBase metadata)
{
NamespaceMetadata namespaceMetadata = new NamespaceMetadata
{
NamespaceName = metadata.NamespaceName
};
Type type = metadata.GetType();
PropertyInfo typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
List <TypeMetadataBase> types = (List <TypeMetadataBase>)ConvertionUtilities.ConvertList(typeof(TypeMetadataBase), (IList)typesProperty?.GetValue(metadata));
if (types != null)
{
namespaceMetadata.Types = types.Select(n => TypeMetadataMapper.EmitTypeForDeserialization(n)).ToList();
}
return(namespaceMetadata);
}
public ParameterMetadata MapToDeserialize(ParameterMetadataBase metadata)
{
ParameterMetadata parameterMetadata = new ParameterMetadata
{
Name = metadata.Name
};
Type type = metadata.GetType();
PropertyInfo typeProperty = type.GetProperty("TypeMetadata", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
TypeMetadataBase typeModel = (TypeMetadataBase)typeProperty?.GetValue(metadata);
if (typeModel != null)
{
parameterMetadata.TypeMetadata = TypeMetadataMapper.EmitTypeForDeserialization(typeModel);
}
return(parameterMetadata);
}
public ParameterMetadataBase MapToSerialize(ParameterMetadata metadata, Type parameterMetadataType)
{
object parameterMetadata = Activator.CreateInstance(parameterMetadataType);
PropertyInfo nameProperty = parameterMetadataType.GetProperty("Name");
PropertyInfo typeProperty = parameterMetadataType.GetProperty("TypeMetadata", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(parameterMetadata, metadata.Name);
if (metadata.TypeMetadata != null)
{
typeProperty?.SetValue(parameterMetadata, typeProperty.PropertyType.Cast(TypeMetadataMapper.EmitTypeToSerialization(metadata.TypeMetadata, typeProperty.PropertyType)));
}
return((ParameterMetadataBase)parameterMetadata);
}
public MethodMetadataBase MapToSerialize(MethodMetadata model, Type methodMetadataType)
{
object methodMetadata = Activator.CreateInstance(methodMetadataType);
PropertyInfo nameProperty = methodMetadataType.GetProperty("Name");
PropertyInfo extensionProperty = methodMetadataType.GetProperty("Extension");
PropertyInfo genericArgumentsProperty = methodMetadataType.GetProperty("GenericArguments", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
PropertyInfo modifiersProperty = methodMetadataType.GetProperty("Modifiers");
PropertyInfo parametersProperty = methodMetadataType.GetProperty("Parameters", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
PropertyInfo returnTypeProperty = methodMetadataType.GetProperty("ReturnType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
nameProperty?.SetValue(methodMetadata, model.Name);
extensionProperty?.SetValue(methodMetadata, model.Extension);
if (model.GenericArguments != null)
{
genericArgumentsProperty?.SetValue(methodMetadata, ConvertionUtilities.ConvertList(genericArgumentsProperty.PropertyType.GetGenericArguments()[0],
model.GenericArguments.Select(t => TypeMetadataMapper.EmitTypeToSerialization(t, genericArgumentsProperty.PropertyType.GetGenericArguments()[0])).ToList()));
}
modifiersProperty?.SetValue(methodMetadata, model.Modifiers);
if (model.Parameters != null)
{
parametersProperty?.SetValue(methodMetadata, ConvertionUtilities.ConvertList(parametersProperty.PropertyType.GetGenericArguments()[0],
model.Parameters.Select(p => new ParameterMetadataMapper().MapToSerialize(p, parametersProperty.PropertyType.GetGenericArguments()[0])).ToList()));
}
if (model.ReturnType != null)
{
returnTypeProperty?.SetValue(methodMetadata, returnTypeProperty.PropertyType.Cast(TypeMetadataMapper.EmitTypeToSerialization(model.ReturnType, returnTypeProperty.PropertyType)));
}
return((MethodMetadataBase)methodMetadata);
}
