public void FillTree (ICSharpCode.TreeView.SharpTreeView tree,Module module)
{
var root = CreateTreeItem(module);
tree.Root = root;
foreach (var ns in module.Namespaces)
{
var namespaceNode = CreateTreeItem(ns);
tree.Root.Children.Add(namespaceNode);
foreach (var type in ns.Types)
{
var typeNode = CreateTreeItem(type);
namespaceNode.Children.Add(typeNode);
foreach (var method in type.Methods)
{
var methodName = CreateTreeItem(method);
namespaceNode.Children.Add(methodName);
}
foreach (var field in type.Fields)
{
var fieldNode = CreateTreeItem(field);
namespaceNode.Children.Add(fieldNode);
}
}
}
}
/// <summary>
/// Reads types from module.
/// </summary>
/// <param name="module">A module where types will be added</param>
/// <param name="types">A collection of types</param>
private void ReadTypes(Module module, Collection<TypeDefinition> types)
{
// first add all types, because i will need find depend types
AddTypes(module, types);
ReadFromTypes(module, types);
}
/// <summary>
/// Reads a module from assembly.
/// </summary>
/// <param name="moduleDefinition">A module which contains information</param>
private void ReadModule(ModuleDefinition moduleDefinition)
{
MainModule = new Module()
{
Name = moduleDefinition.Name
};
Modules.Add(MainModule);
if (moduleDefinition.HasTypes)
ReadTypes(MainModule, moduleDefinition.Types);
}
/// <summary>
/// Iterates through a collection of types and add them to the module.
/// </summary>
/// <param name="module">A module where types will be added</param>
/// <param name="types">A collection of types</param>
private void AddTypes(Module module, Collection<TypeDefinition> types)
{
foreach (TypeDefinition typeDefinition in types)
{
if (typeDefinition.Name != "<Module>")
{
var type = CreateType(module, typeDefinition);
if (typeDefinition.HasNestedTypes)
AddNestedTypes(type, typeDefinition.NestedTypes);
}
}
}
/// <summary>
/// Reads generic arguments from type and returns them as a set of types
/// </summary>
/// <param name="module">The module where are types located</param>
/// <param name="genericInstance">The instance type</param>
/// <returns>A set of types used by generic instance</returns>
public ISet<Type> ReadGenericArguments(Module module, GenericInstanceType genericInstance)
{
var types = new HashSet<Type>();
foreach (var parameter in genericInstance.GenericArguments)
{
var type =
(from n in module.Namespaces
from t in n.Types
where t.FullName == FormatTypeName(parameter, true)
select t).SingleOrDefault();
if (type != null) //
types.Add(type);
if (parameter.IsGenericInstance)
types.UnionWith(ReadGenericArguments(module, (GenericInstanceType) parameter));
}
return types;
}
/// <summary>
/// Reads fields, events, methods from a type.
/// </summary>
/// <param name="module">A module where are types located</param>
/// <param name="types">A collection of types</param>
private void ReadFromTypes(Module module, Collection<TypeDefinition> types)
{
foreach (TypeDefinition typeDefinition in types)
{
if (typeDefinition.Name != "<Module>")
{
var type =
(from n in module.Namespaces
from t in n.Types
where t.FullName == FormatTypeName(typeDefinition, true)
select t).SingleOrDefault();
if (typeDefinition.BaseType != null)
{
var baseType = (from n in module.Namespaces
from t in n.Types
where (t.FullName == FormatTypeName(typeDefinition.BaseType, true))
select t).SingleOrDefault();
type.BaseType = baseType; // if baseType is null so propably inherits from another assembly
if (typeDefinition.BaseType.IsGenericInstance)
{
type.IsBaseTypeGenericInstance = true;
type.GenericBaseTypes.UnionWith(ReadGenericArguments(type.Namespace.Module,
(GenericInstanceType)typeDefinition.BaseType));
}
}
// looks for implemented interfaces
if (typeDefinition.HasInterfaces)
{
foreach (var ic in typeDefinition.Interfaces)
{
var implementedIc = (from n in module.Namespaces
from t in n.Types
where (t.FullName == FormatTypeName(ic, true))
select t).SingleOrDefault();
if (implementedIc != null)
type.ImplementedInterfaces.Add(implementedIc);
if (ic.IsGenericInstance)
{
type.GenericBaseTypes.UnionWith(ReadGenericArguments(type.Namespace.Module,
(GenericInstanceType)ic));
}
}
}
if (typeDefinition.HasFields)
ReadFields(type, typeDefinition.Fields);
if (typeDefinition.HasEvents)
ReadEvents(type, typeDefinition.Events);
if (typeDefinition.HasMethods)
ReadMethods(type, typeDefinition.Methods);
if (typeDefinition.HasNestedTypes)
ReadFromTypes(module, typeDefinition.NestedTypes);
}
}
}
/// <summary>
/// Creates a type. If type exist in namespace which isn't created yet so it will be created.
/// </summary>
/// <param name="module">A module where type will be added</param>
/// <param name="typeDefinition">TypeDefinition which will used to create a type.</param>
/// <returns>A new type</returns>
private Type CreateType(Module module, TypeDefinition typeDefinition)
{
var type = new Type
{
Name = FormatTypeName(typeDefinition),
FullName = FormatTypeName(typeDefinition, true),
IsInterface = typeDefinition.IsInterface,
IsEnum = typeDefinition.IsEnum,
IsClass = typeDefinition.IsClass,
IsSealed = typeDefinition.IsSealed,
IsAbstract = typeDefinition.IsAbstract,
IsPublic = typeDefinition.IsPublic,
IsStruct = typeDefinition.IsValueType && !typeDefinition.IsEnum && typeDefinition.IsSealed,
IsInternal = typeDefinition.IsNotPublic,
IsDelegate = (typeDefinition.BaseType != null ?
typeDefinition.BaseType.FullName == "System.MulticastDelegate" : false),
IsNestedPrivate = typeDefinition.IsNestedPrivate,
IsNestedPublic = typeDefinition.IsNestedPublic,
IsNestedProtected = (!typeDefinition.IsNestedPrivate && !typeDefinition.IsNestedPublic &&
typeDefinition.IsNestedFamily)
};
// try find namespace
var nsName = GetNamespaceName(typeDefinition);
var ns = (from n in module.Namespaces
where n.Name == nsName
select n).SingleOrDefault();
if (ns == null)
{
ns = new Namespace
{
Name = nsName,
Module = module
};
module.Namespaces.Add(ns);
}
type.Namespace = ns;
ns.Types.Add(type);
return type;
}
public static BitmapSource GetIcon(Module module)
{
return Assembly;
}
