/// <summary> /// Processes the public constructor overloads. /// </summary> /// <param name="exportedType">The <see cref="DocExportedType"/>.</param> private void ProcessConstructors(DocExportedType exportedType) { if (!exportedType.IsClass) { return; } exportedType.Constructor = new DocConstructor(exportedType) { Name = exportedType.Name, }; var ctors = exportedType.Type.GetConstructors().Concat( exportedType.Type.GetConstructors(BindingFlags.Static | BindingFlags.NonPublic)).Distinct() .OrderBy(c => c.IsStatic ? 1 : 0).ThenBy(c => c.GetParameters().Length); foreach (var ctor in ctors) { var overload = new DocOverload(ctor, exportedType.Constructor) { Name = MemberUtils.GenerateCodeFor(ctor), XPath = MemberUtils.GetSelector(ctor), }; LinkCache.Register(overload); var staticText = ctor.IsStatic ? " static " : " "; overload.Code = $"public{staticText}{overload.Name}"; ProcessParameters(ctor.GetParameters(), overload, overload.Parameters); exportedType.Constructor.Overloads.Add(overload); } }
/// <summary> /// Iterate the types for the namespace. /// </summary> /// <param name="docNamespace">The <see cref="DocNamespace"/> to parse into.</param> private void IterateTypes(DocNamespace docNamespace) { foreach (var type in Types.Where(t => t.Namespace == docNamespace.Name)) { Console.WriteLine($"Parsing type \"{type.FullName}\"..."); var exportedType = new DocExportedType { Namespace = docNamespace, }; ProcessType(type, exportedType); docNamespace.Types.Add(exportedType); } }
/// <summary> /// Parses a <see cref="DocExportedType"/> to a <see cref="DocFile"/>. /// </summary> /// <param name="t">The <see cref="DocExportedType"/> to parse.</param> /// <returns>The transformed <see cref="DocFile"/>.</returns> private DocFile ProcessType(DocExportedType t) { var result = new DocFile(t.FileName); var classification = t.IsInterface ? "Interface" : (t.IsEnum ? "Enum" : "Class"); result.AddThenBlankLine(writer.WriteHeading1($"{MarkdownWriter.Normalize(t.TypeRef.FriendlyName)} {classification}")); result.AddThenBlankLine(ParserUtils.ProcessBreadcrumb(t)); result.AddThenBlankLine(t.Description); ExtractCode(t.Code, result); ExtractTypeParameters(t.TypeParameters, result); if (t.Inheritance.Any()) { result.AddThenBlankLine(ParserUtils.ParseInheritance(t.Inheritance)); } if (t.ImplementedInterfaces.Any()) { result.AddThenBlankLine(ParserUtils .ParseImplementedInterfaces(t.ImplementedInterfaces)); } if (t.DerivedTypes.Any()) { result.AddThenBlankLine(ParserUtils .ParseDerivedTypes(t.DerivedTypes)); } ExtractExamples(t.Example, result); ExtractRemarks(t.Remarks, result); ExtractCtors(t.Constructor, result); ExtractProperties(t.Properties, result); ExtractMethods(t, result); return(result); }
/// <summary> /// Processes the public method overloads. /// </summary> /// <param name="exportedType">The <see cref="DocExportedType"/>.</param> private void ProcessMethods(DocExportedType exportedType) { var typePropertyMethods = exportedType.Type.GetProperties() .Select(p => new[] { p.GetMethod, p.SetMethod }) .SelectMany(p => p) .Where(p => p != null) .Distinct(); var typeMethods = exportedType.Type.GetMethods( BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance).Where(m => m.DeclaringType == exportedType.Type) .Except(typePropertyMethods); foreach (var methodInfo in typeMethods) { var method = exportedType.Methods.FirstOrDefault(m => m.Name == methodInfo.Name); if (method == null) { method = new DocMethod(exportedType) { Name = methodInfo.Name, MethodReturnType = TypeCache.Cache[methodInfo.ReturnType], }; exportedType.Methods.Add(method); } var methodOverload = new DocMethodOverload(methodInfo, method) { Name = MemberUtils.GenerateCodeFor(methodInfo), XPath = MemberUtils.GetSelector(methodInfo), }; LinkCache.Register(methodOverload); methodOverload.Code = methodOverload.Name; ProcessParameters(methodInfo.GetParameters(), methodOverload, methodOverload.Parameters); method.MethodOverloads.Add(methodOverload); } }
/// <summary> /// Process property information. /// </summary> /// <param name="exportedType">The <see cref="DocExportedType"/> to parse.</param> private void ProcessProperties(DocExportedType exportedType) { var defaultRules = typeof(DefaultComparisonRules); foreach (var prop in exportedType.Type.GetProperties( BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) { if (prop.DeclaringType != exportedType.Type) { continue; } var property = new DocProperty(exportedType) { Name = $"{exportedType.Name}.{prop.Name}", XPath = MemberUtils.GetSelector(prop), Type = prop.PropertyType, TypeParameters = ProcessTypeParameters(prop.PropertyType), Code = MemberUtils.GenerateCodeFor(prop), }; if (exportedType.Type == defaultRules && prop.GetMethod.IsStatic) { var expression = prop.GetMethod.Invoke(null, null); property.CustomInfo = expression.ToString(); } LinkCache.Register(property); if (prop.GetIndexParameters().Length > 0) { property.IsIndexer = true; property.IndexerType = TypeCache.Cache[prop.GetIndexParameters().First().ParameterType]; } property.TypeParameter = exportedType.TypeParameters.FirstOrDefault( t => t.Name == property.Type.Name); exportedType.Properties.Add(property); } }
/// <summary> /// Initializes a new instance of the <see cref="DocProperty"/> class with a /// <see cref="DocExportedType"/>. /// </summary> /// <param name="parent">The parent <see cref="DocExportedType"/>.</param> public DocProperty(DocExportedType parent) { ParentType = parent; }