private static string generateInner(IEnumerable <Type> types, TsReflectionFilters filters) { var cb = new TypescriptCodeBuilder(); var lastNamespace = ""; var scope = null as ScriptScope; types = types.OrderBy(t => t.ToTsName()).OrderBy(t => t.GetTsNamespace()); foreach (var t in types) { // namespace var ns = t.GetTsNamespace(); if (ns != lastNamespace) { scope?.Dispose(); scope = cb.EnterNameSpace(ns); lastNamespace = ns; } // class var baseTypes = t.BaseType?.ToTsName() != "any" && filters.TypeFilter(t.BaseType) ? new[] { t.BaseType.ToTsFullName() } : null; var interfaces = t.GetInterfaces() .Where(i => filters.TypeFilter(i)) .Select(i => i.ToTsFullName()) .ToArray(); if (t.IsEnum) { GenerateEnum(t, cb); } else { using (cb.EnterClass(t.ToTsName(), baseTypes, interfaces, Ambient.export)) { // property foreach (var prop in t.GetProperties().Where(p => filters.PropertyFilter(t, p))) { cb.AppendLine($"{prop.Name} : {prop.PropertyType.ToTsFullName()};"); } // field foreach (var field in t.GetFields().Where(f => filters.FieldFilter(t, f))) { cb.AppendLine($"{field.Name} : {field.FieldType.ToTsFullName()};"); } } } } scope?.Dispose(); return(cb.ToString()); }
public static List <Type> ListUpDependeceTypes(Type[] types, TsReflectionFilters filters = null) { if (types == null) { throw new ArgumentNullException("types must be not null."); } if (types.Length < 1) { throw new ArgumentOutOfRangeException("types.Length must be > 0."); } var typeList = new List <Type>(); var stack = new List <Type>(); stack.AddRange(types); var index = 0; if (filters == null) { filters = TsReflectionFilters.DefaultFilters; } while (stack.Count > index) { var target = stack[index]; index++; if (typeList.Contains(target)) { continue; } if (typeList.Any(t => t.ToTsFullName() == target.ToTsFullName())) { continue; } if (target.IsNotPublic) { continue; } if (target.IsTsBuiltinType()) { continue; } if (target.IsGenericParameter) { continue; } if (target.IsEnum) { if (!stack.Contains(target.BaseType)) { stack.Add(target.BaseType); } if (filters.EnumFilter(target)) { typeList.Add(target); } continue; } if (target.IsArray) { if (!stack.Contains(target.GetElementType())) { stack.Add(target.GetElementType()); } continue; } if (target.IsTsCollection() || target.IsTsDictionary()) { if (target.IsGenericType) { foreach (var t in target.GenericTypeArguments) { if (!stack.Contains(t)) { stack.Add(t); } } } continue; } if (target.BaseType != null) { if (!stack.Contains(target.BaseType)) { stack.Add(target.BaseType); } } var interfaces = target.GetInterfaces(); foreach (var i in interfaces) { if (!stack.Contains(i)) { stack.Add(i); } } var properties = target.GetProperties(); foreach (var p in properties) { if (filters.PropertyFilter(target, p)) { if (!stack.Contains(p.PropertyType)) { stack.Add(p.PropertyType); } } } var fields = target.GetFields(); foreach (var f in fields) { if (filters.FieldFilter(target, f)) { if (!stack.Contains(f.FieldType)) { stack.Add(f.FieldType); } } } var methods = target.GetMethods(); foreach (var m in methods) { if (filters.MethodFilter(target, m)) { if (!stack.Contains(m.ReturnType)) { stack.Add(m.ReturnType); } foreach (var p in m.GetParameters()) { if (!stack.Contains(p.ParameterType)) { stack.Add(p.ParameterType); } } } } if (target.IsGenericType) { foreach (var t in target.GenericTypeArguments) { if (!stack.Contains(t)) { stack.Add(t); } } var gt = target.GetGenericTypeDefinition(); if (gt != null && gt != target) { if (!stack.Contains(gt)) { stack.Add(gt); } continue; } } if (filters.TypeFilter(target)) { typeList.Add(target); } } return(typeList); }