Example #1
0
        private MethodDoc ParseMethod(Type type, MethodInfo method, XmlDocTree xmlDocTree)
        {
            MethodDoc methodDoc = new MethodDoc()
            {
                Name           = method.Name,
                ReturnType     = method.ReturnType,
                IsStatic       = method.IsStatic,
                IsAbstract     = method.IsAbstract,
                InheritedFrom  = method.DeclaringType == type ? null : method.DeclaringType,
                Obsolete       = method.IsDefined(typeof(ObsoleteAttribute), true),
                ObsoleteString = method.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
            };

            DocMember member = xmlDocTree.GetDocumentation(method);

            if (member != null)
            {
                methodDoc.Summary       = member.Summary;
                methodDoc.ReturnSummary = member.ReturnsSummary;
            }

            methodDoc.Parameters = ParseParameters(method, member);

            return(methodDoc);
        }
Example #2
0
        private void ParseClass(Type type, XmlDocTree xmlDocTree)
        {
            ClassTypeDoc classType = new ClassTypeDoc()
            {
                Name           = type.Name,
                Type           = type,
                Namespace      = type.Namespace,
                IsGeneric      = type.IsGenericType,
                IsStatic       = type.IsAbstract && type.IsSealed,
                IsAbstract     = type.IsAbstract,
                IsSealed       = type.IsSealed,
                Obsolete       = type.IsDefined(typeof(ObsoleteAttribute), true),
                ObsoleteString = type.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
            };

            foreach (MethodInfo method in type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static).Where(x => !x.IsSpecialName))
            {
                classType.Methods.Add(ParseMethod(type, method, xmlDocTree));
            }

            foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
            {
                classType.Fields.Add(ParseField(type, field, xmlDocTree));
            }

            foreach (PropertyInfo property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
            {
                classType.Properties.Add(ParseProperty(type, property, xmlDocTree));
            }

            foreach (ConstructorInfo constructor in type.GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static))
            {
                classType.Constructors.Add(ParseConstructor(type, constructor, xmlDocTree));
            }

            DocMember member = xmlDocTree.GetDocumentation(type);

            if (member != null)
            {
                classType.Summary = member.Summary;
            }

            docTypes.Add(classType);
        }
Example #3
0
        private ConstructorDoc ParseConstructor(Type type, ConstructorInfo constructor, XmlDocTree xmlDocTree)
        {
            ConstructorDoc constructorDoc = new ConstructorDoc()
            {
                Type           = type,
                Obsolete       = constructor.IsDefined(typeof(ObsoleteAttribute), true),
                ObsoleteString = constructor.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
            };

            DocMember member = xmlDocTree.GetDocumentation(constructor);

            if (member != null)
            {
                constructorDoc.Summary = member.Summary;
            }

            constructorDoc.Parameters = ParseParameters(constructor, member);

            return(constructorDoc);
        }
Example #4
0
        private FieldDoc ParseField(Type type, FieldInfo field, XmlDocTree xmlDocTree)
        {
            FieldDoc fieldDoc = new FieldDoc()
            {
                Name           = field.Name,
                Type           = field.FieldType,
                InheritedFrom  = field.DeclaringType == type ? null : field.DeclaringType,
                IsStatic       = field.IsStatic,
                Obsolete       = field.IsDefined(typeof(ObsoleteAttribute), true),
                ObsoleteString = field.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
            };

            DocMember member = xmlDocTree.GetDocumentation(field);

            if (member != null)
            {
                fieldDoc.Summary = member.Summary;
            }

            return(fieldDoc);
        }
Example #5
0
        private PropertyDoc ParseProperty(Type type, PropertyInfo property, XmlDocTree xmlDocTree)
        {
            PropertyDoc propertyDoc = new PropertyDoc()
            {
                Name           = property.Name,
                Type           = property.PropertyType,
                Getter         = property.CanRead,
                Setter         = property.CanWrite,
                InheritedFrom  = property.DeclaringType == type ? null : property.DeclaringType,
                Obsolete       = property.IsDefined(typeof(ObsoleteAttribute), true),
                ObsoleteString = property.GetCustomAttribute <ObsoleteAttribute>(true)?.Message
            };

            DocMember member = xmlDocTree.GetDocumentation(property);

            if (member != null)
            {
                propertyDoc.Summary = member.Summary;
            }

            return(propertyDoc);
        }
Example #6
0
        private void ParseEnum(Type type, XmlDocTree xmlDocTree)
        {
            EnumTypeDoc enumType = new EnumTypeDoc()
            {
                Name      = type.Name,
                Type      = type,
                Namespace = type.Namespace
            };

            foreach (string name in type.GetEnumNames())
            {
                EnumDoc enumValue = new EnumDoc()
                {
                    Name = name
                };

                DocMember member = xmlDocTree.GetDocumentationEnumValue(type, name);

                if (member != null)
                {
                    enumValue.Summary = member.Summary;
                }

                enumType.Values.Add(enumValue);
            }

            {
                DocMember member = xmlDocTree.GetDocumentation(type);

                if (member != null)
                {
                    enumType.Summary = member.Summary;
                }
            }

            docTypes.Add(enumType);
        }