private TypeDocument ReadEntity(Type type, string name)
{
if (type == typeof(void))
{
return(null);
}
if (!IsLetter(type.Name[0]))
{
return(null);
}
var typeDocument = new TypeDocument
{
Name = name,
TypeName = ReflectionHelper.GetTypeName(type),
ClassName = ReflectionHelper.GetTypeName(type),
ObjectType = ObjectType.Object
};
typeDocument.Copy(XmlMember.Find(type));
ReadEntity(typeDocument, type);
return(typeDocument);
}
TypeDocument CheckMember(TypeDocument document, Type parent, MemberInfo member, Type memType, bool json, bool dc, bool checkBase = true)
{
if (document.Fields.ContainsKey(member.Name))
{
return(null);
}
var jp = member.GetAttribute <JsonPropertyAttribute>();
var dm = member.GetAttribute <DataMemberAttribute>();
if (json)
{
var ji = member.GetAttribute <JsonIgnoreAttribute>();
if (ji != null)
{
return(null);
}
if (jp == null)
{
return(null);
}
}
else if (dc)
{
var id = member.GetAttribute <IgnoreDataMemberAttribute>();
if (id != null)
{
return(null);
}
}
var field = new TypeDocument();
var doc = XmlMember.Find(parent, member.Name);
field.Copy(doc);
bool isArray = false;
bool isDictionary = false;
try
{
Type type = memType;
if (memType.IsArray)
{
isArray = true;
type = type.Assembly.GetType(type.FullName.Split('[')[0]);
}
else if (type.IsGenericType)
{
if (memType.IsSupperInterface(typeof(ICollection <>)))
{
isArray = true;
type = type.GetGenericArguments()[0];
}
else if (memType.IsSupperInterface(typeof(IDictionary <,>)))
{
var fields = type.GetGenericArguments();
field.Fields.Add("Key", ReadEntity(fields[0], "Key"));
field.Fields.Add("Value", ReadEntity(fields[1], "Value"));
isDictionary = true;
checkBase = false;
}
}
if (type.IsEnum)
{
if (checkBase)
{
field = ReadEntity(type, member.Name);
}
field.ObjectType = ObjectType.Base;
field.IsEnum = true;
}
else if (type.IsBaseType())
{
field.ObjectType = ObjectType.Base;
}
else if (!isDictionary)
{
if (checkBase)
{
field = ReadEntity(type, member.Name);
}
field.ObjectType = ObjectType.Object;
}
field.TypeName = ReflectionHelper.GetTypeName(type);
}
catch
{
field.TypeName = "object";
}
if (isArray)
{
field.TypeName += "[]";
field.ObjectType = ObjectType.Array;
}
else if (isDictionary)
{
field.TypeName = "Dictionary";
field.ObjectType = ObjectType.Dictionary;
}
field.Name = member.Name;
field.JsonName = member.Name;
field.ClassName = ReflectionHelper.GetTypeName(memType);
if (!string.IsNullOrWhiteSpace(dm?.Name))
{
field.JsonName = dm.Name;
}
if (!string.IsNullOrWhiteSpace(jp?.PropertyName))
{
field.JsonName = jp.PropertyName;
}
var rule = member.GetAttribute <DataRuleAttribute>();
if (rule != null)
{
field.CanNull = rule.CanNull;
field.Regex = rule.Regex;
if (rule.Min != long.MinValue)
{
field.Min = rule.Min;
}
if (rule.Max != long.MinValue)
{
field.Max = rule.Max;
}
if (rule.MinDate != DateTime.MinValue)
{
field.MinDate = rule.MinDate;
}
if (rule.MaxDate != DateTime.MaxValue)
{
field.MaxDate = rule.MaxDate;
}
}
document.Fields.Add(member.Name, field);
return(field);
}
private void ReadEntity(TypeDocument typeDocument, Type type)
{
if (type == null || type.IsAutoClass || !IsLetter(type.Name[0]) ||
type.IsInterface || type.IsMarshalByRef || type.IsCOMObject ||
type == typeof(object) || type == typeof(void) ||
type == typeof(ValueType) || type == typeof(Type) || type == typeof(Enum) ||
type.Namespace == "System" || type.Namespace?.Contains("System.") == true)
{
return;
}
if (typeDocs.TryGetValue(type, out var doc))
{
foreach (var field in doc.Fields)
{
if (typeDocument.Fields.ContainsKey(field.Key))
{
typeDocument.Fields[field.Key] = field.Value;
}
else
{
typeDocument.Fields.Add(field.Key, field.Value);
}
}
return;
}
if (typeDocs2.TryGetValue(type, out var _))
{
ZeroTrace.WriteError("ReadEntity", "over flow", type.Name);
return;
}
typeDocs2.Add(type, typeDocument);
if (type.IsArray)
{
ReadEntity(typeDocument, type.Assembly.GetType(type.FullName.Split('[')[0]));
return;
}
if (type.IsGenericType && !type.IsValueType &&
type.GetGenericTypeDefinition().GetInterface(typeof(IEnumerable <>).FullName) != null)
{
ReadEntity(typeDocument, type.GetGenericArguments().Last());
return;
}
XmlMember.Find(type);
if (type.IsEnum)
{
foreach (var field in type.GetFields(BindingFlags.Static | BindingFlags.Public))
{
if (field.IsSpecialName)
{
continue;
}
var info = CheckMember(typeDocument, type, field, field.FieldType, false, false, false);
if (info != null)
{
info.TypeName = "int";
info.Example = ((int)field.GetValue(null)).ToString();
info.JsonName = null;
}
}
typeDocs.Add(type, new TypeDocument
{
fields = typeDocument.fields?.ToDictionary(p => p.Key, p => p.Value)
});
typeDocument.Copy(XmlMember.Find(type));
return;
}
var dc = type.GetAttribute <DataContractAttribute>();
var jo = type.GetAttribute <JsonObjectAttribute>();
foreach (var property in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (property.IsSpecialName)
{
continue;
}
CheckMember(typeDocument, type, property, property.PropertyType, jo != null, dc != null);
}
foreach (var field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (!char.IsLetter(field.Name[0]) || field.IsSpecialName)
{
continue;
}
CheckMember(typeDocument, type, field, field.FieldType, jo != null, dc != null);
}
typeDocs.Add(type, new TypeDocument
{
fields = typeDocument.fields?.ToDictionary(p => p.Key, p => p.Value)
});
typeDocument.Copy(XmlMember.Find(type));
}
void CheckMember(TypeDocument document, Type parent, MemberInfo member, Type memType, bool json, bool dc)
{
if (!IsLetter(member.Name[0]))
{
return;
}
var field = new TypeDocument();
try
{
Type type = memType;
if (memType.IsSubclassOf(typeof(IList <>)))
{
type = type.GetGenericArguments()[0];
}
if (memType.IsSubclassOf(typeof(IDictionary <,>)))
{
type = type.GetGenericArguments()[1];
}
if (memType.IsArray)
{
type = type.MakeArrayType();
}
if (type.IsEnum)
{
field = ReadEntity(type, member.Name);
field.ObjectType = ObjectType.Base;
field.IsEnum = type.IsEnum;
}
else if (type.IsBaseType())
{
field.ObjectType = ObjectType.Base;
field.TypeName = ReflectionHelper.GetTypeName(type);
}
else
{
field = ReadEntity(type, member.Name);
field.ObjectType = ObjectType.Object;
}
}
catch
{
field.TypeName = "object";
}
field.Copy(XmlMember.Find(parent, member.Name, member is PropertyInfo ? "P" : "F"));
field.Name = field.JsonName = member.Name;
field.ClassName = ReflectionHelper.GetTypeName(memType);
if (json)
{
var ji = member.GetAttribute <JsonIgnoreAttribute>();
if (ji != null)
{
return;
}
var jp = member.GetAttribute <JsonPropertyAttribute>();
if (jp == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(jp.PropertyName))
{
field.JsonName = jp.PropertyName;
}
}
else if (dc)
{
var id = member.GetAttribute <IgnoreDataMemberAttribute>();
if (id != null)
{
return;
}
var dm = member.GetAttribute <DataMemberAttribute>();
if (dm != null && !string.IsNullOrWhiteSpace(dm.Name))
{
field.JsonName = dm.Name;
}
}
if (memType.IsSubclassOf(typeof(IList <>)))
{
field.ObjectType = ObjectType.Array;
}
else if (memType.IsSubclassOf(typeof(IDictionary <,>)))
{
field.ObjectType = ObjectType.Dictionary;
}
else if (memType.IsArray)
{
field.ObjectType = ObjectType.Array;
}
var rule = member.GetAttribute <DataRuleAttribute>();
if (rule != null)
{
field.CanNull = rule.CanNull;
field.Regex = rule.Regex;
if (rule.Min != long.MinValue)
{
field.Min = rule.Min;
}
if (rule.Max != long.MinValue)
{
field.Max = rule.Max;
}
if (rule.MinDate != DateTime.MinValue)
{
field.MinDate = rule.MinDate;
}
if (rule.MaxDate != DateTime.MaxValue)
{
field.MaxDate = rule.MaxDate;
}
}
document.Fields.Add(member.Name, field);
}