public static MarkdownableType[] Load(string dllPath, List <string> whitelist)
{
string xmlPath = Path.Combine(Directory.GetParent(dllPath).FullName, Path.GetFileNameWithoutExtension(dllPath) + ".xml");
XmlDocumentComment[] comments = new XmlDocumentComment[0];
if (File.Exists(xmlPath))
{
comments = VSDocParser.ParseXmlComment(XDocument.Parse(File.ReadAllText(xmlPath)));
}
var commentsLookup = comments.ToLookup(x => x.ClassName);
MarkdownableType[] markdownableTypes = new[] { Assembly.LoadFrom(dllPath) }
.SelectMany(x => {
try {
return(x.GetTypes());
}
catch (ReflectionTypeLoadException ex) {
return(ex.Types.Where(t => t != null));
}
catch {
return(Type.EmptyTypes);
}
})
.Where(x => x != null) // Filter null types
.Where(x => whitelist == null || whitelist.Contains(x.Namespace)) // Filter namespace by whitelist
.Where(x => x.IsPublic && !typeof(Delegate).IsAssignableFrom(x) && !x.GetCustomAttributes <ObsoleteAttribute>().Any())
.Select(x => new MarkdownableType(x, commentsLookup))
.ToArray();
return(markdownableTypes);
}
public static MarkdownableType[] Load(string dllPath, string namespaceMatch)
{
var xmlPath = Path.Combine(Directory.GetParent(dllPath).FullName, Path.GetFileNameWithoutExtension(dllPath) + ".xml");
var assembly = Assembly.LoadFrom(dllPath);
//var aType = assembly.GetType("System.Reactive.Subjects.Subject`1");
//var methods = aType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.InvokeMethod);
//var methods = aType.GetRuntimeMethods();
XmlDocumentComment[] comments = new XmlDocumentComment[0];
if (File.Exists(xmlPath))
{
comments = VSDocParser.ParseXmlComment(XDocument.Parse(File.ReadAllText(xmlPath)), namespaceMatch, assembly);
}
var commentsLookup = comments.ToLookup(x => x.ClassName);
var namespaceRegex =
!string.IsNullOrEmpty(namespaceMatch) ? new Regex(namespaceMatch) : null;
var markdownableTypes = new[] { assembly }
.SelectMany(x =>
{
try
{
return(x.GetTypes());
}
catch (ReflectionTypeLoadException ex)
{
return(ex.Types.Where(t => t != null));
}
catch
{
return(Type.EmptyTypes);
}
})
.Where(x => x != null)
.Where(x => x.IsPublic && !typeof(Delegate).IsAssignableFrom(x) /* && !x.GetCustomAttributes<ObsoleteAttribute>().Any()*/)
.Where(x => IsRequiredNamespace(x, namespaceRegex))
.Select(x => new MarkdownableType(x, commentsLookup))
.ToArray();
return(markdownableTypes);
}
public static MarkdownableType[] Load(string dllPath, string namespaceMatch)
{
string xmlPath = Path.Combine(Directory.GetParent(dllPath).FullName, Path.GetFileNameWithoutExtension(dllPath) + ".xml");
XmlDocumentComment[] comments = new XmlDocumentComment[0];
if (File.Exists(xmlPath))
{
comments = VSDocParser.ParseXmlComment(XDocument.Parse(File.ReadAllText(xmlPath)), namespaceMatch);
}
ILookup <string, XmlDocumentComment> commentsLookup = comments.ToLookup(x => x.ClassName);
Regex namespaceRegex =
!string.IsNullOrEmpty(namespaceMatch) ? new Regex(namespaceMatch) : null;
MarkdownableType[] markdownableTypes = new[] { Assembly.LoadFrom(dllPath) }
.SelectMany(x =>
{
try
{
return(x.GetTypes());
}
catch (ReflectionTypeLoadException ex)
{
return(ex.Types.Where(t => t != null));
}
catch
{
return(Type.EmptyTypes);
}
})
.Where(x => x != null)
.Where(x => x.IsPublic && !typeof(Delegate).IsAssignableFrom(x) && !x.GetCustomAttributes <ObsoleteAttribute>().Any())
.Where(x => IsRequiredNamespace(x, namespaceRegex))
.Select(x => new MarkdownableType(x, commentsLookup))
.ToArray();
return(markdownableTypes);
}
public static MarkdownableType[] Load(string dllPath, string namespaceMatch)
{
var xmlPath = Path.Combine(Directory.GetParent(dllPath).FullName, Path.GetFileNameWithoutExtension(dllPath) + ".xml");
XmlDocumentComment[] comments = new XmlDocumentComment[0];
if (File.Exists(xmlPath))
{
comments = VSDocParser.ParseXmlComment(XDocument.Parse(File.ReadAllText(xmlPath)), namespaceMatch);
}
var commentsLookup = comments.ToLookup(x => x.ClassName);
var namespaceRegex =
!string.IsNullOrEmpty(namespaceMatch) ? new Regex(namespaceMatch) : null;
IEnumerable <Type> TypesSelector(Type type)
{
var types = type.GetNestedTypes();
var typeList = new List <Type>
{
type
};
if (types.Length == 0)
{
return(typeList);
}
typeList.AddRange(types.SelectMany(TypesSelector).ToArray());
return(typeList);
}
IEnumerable <Type> AssemblyTypesSelector(Assembly x)
{
try
{
var types = x.GetTypes().SelectMany(TypesSelector);
return(types);
}
catch (ReflectionTypeLoadException ex)
{
return(ex.Types.Where(t => t != null));
}
catch
{
return(Type.EmptyTypes);
}
}
bool NotNullPredicate(Type x)
{
return(x != null);
}
bool NamespaceFilterPredicate(Type x)
{
var _IsRequiredNamespace = IsRequiredNamespace(x, namespaceRegex);
return(_IsRequiredNamespace);
}
MarkdownableType markdownableTypeSelector(Type x)
{
MarkdownableType markdownableType = new MarkdownableType(x, commentsLookup);
return(markdownableType);
}
bool OthersPredicate(Type x)
{
var IsPublic = x.IsPublic || (x.IsNested && x.IsNestedPublic);
var IsAssignableFromDelegate = typeof(Delegate).IsAssignableFrom(x);
var HaveObsoleteAttribute = x.GetCustomAttributes <ObsoleteAttribute>().Any();
return(IsPublic && !IsAssignableFromDelegate && !HaveObsoleteAttribute);
}
var dllAssemblys = new[] { Assembly.LoadFrom(dllPath) };
var markdownableTypes = dllAssemblys
.SelectMany(AssemblyTypesSelector)
.Where(NotNullPredicate)
.Where(OthersPredicate)
.Where(NamespaceFilterPredicate)
.Select(markdownableTypeSelector)
.ToArray();
return(markdownableTypes);
}