private static Tuple <ReflectNamespace, ReflectAssembly> FindNamespaceAndAssembly(Type type) { var asm = FindAssembly(type.Assembly.GetName().Name); if (asm == null) { asm = new ReflectAssembly { Name = type.Assembly.GetName().Name, FullName = type.Assembly.GetName().FullName, Version = type.Assembly.ImageRuntimeVersion, //Namespaces = new Tree<string, ReflectNamespace>(), PublicKey = PublicKeyToString( type.Assembly.GetName().GetPublicKey()), Context = new ReflectContext() { Assemblies = new Dictionary <string, ReflectAssembly>(), Folder = "NotFound", Name = "NotFound", Namespaces = new Tree <string, ReflectNamespace>() } } } ; var ns = FindNamespace(type.Namespace); if (ns == null) { ns = new ReflectNamespace() { Assembly = asm, Name = type.Namespace, Types = new Dictionary <string, Lazy <ReflectType> >() } } ; return(new Tuple <ReflectNamespace, ReflectAssembly>(ns, asm)); }
public static void AddContext(string context, string path) { if (AssemblyModel.Contexts.ContainsKey(context)) { return; } var directoryInfo = new DirectoryInfo(path); if (!directoryInfo.Exists) { throw new InvalidPathAssemblyModelException(path); } var newCtx = new ReflectContext() { Name = context, Folder = path, Assemblies = new Dictionary <string, ReflectAssembly>(), Namespaces = new Tree <string, ReflectNamespace>() }; Contexts.Add(context, newCtx); foreach (var file in directoryInfo.GetFiles("*.dll")) { Assembly asm = null; try { asm = Assembly.LoadFrom(file.FullName); } catch { continue; } //Ignores Invalid type of Exception var newassembly = new ReflectAssembly { Context = newCtx, Name = asm.GetName().Name, FullName = asm.GetName().FullName, Version = asm.ImageRuntimeVersion, //Namespaces = new Tree<string, ReflectNamespace>(), PublicKey = PublicKeyToString(asm.GetName().GetPublicKey()) }; newCtx.Assemblies.Add(newassembly.Name, newassembly); try { foreach (var type in asm.GetTypes()) { } } catch { //Inheritance security rules violated by type: 'System.Web.DynamicData.ControlFilterExpression'. Derived types must either match the security accessibility of the base type or be less accessible.":"System.Web.DynamicData.ControlFilterExpression"} continue; } foreach (var type in asm.GetTypes()) { //adds to context namespace list if (type.Namespace != null && type.IsPublic) { ReflectNamespace newNamesspace; if (!newCtx.Namespaces.ContainsKey(type.Namespace.Split('.'))) { newNamesspace = new ReflectNamespace() { Name = type.Namespace, Assembly = newassembly, Types = new Dictionary <string, Lazy <ReflectType> >() }; if (!newCtx.Namespaces.ContainsKey(newNamesspace.Name.Split('.'))) { newCtx.Namespaces.Add(newNamesspace.Name.Split('.'), newNamesspace); //fills null Objects with Namespaces must be on reverse order var namespaceStack = new Stack <string>(newNamesspace.Name.Split('.').Reverse()); var namespaceList = new StringBuilder(); //namespaceList.Append(namespaceStack.Pop()); foreach (var name in namespaceStack) { if (namespaceList.Length == 0) { namespaceList.Append(name); } else { namespaceList.Append(".").Append(name); } var value = newCtx.Namespaces.GetValue(namespaceList.ToString().Split('.')); if (value == null) { newCtx.Namespaces.SetValue(namespaceList.ToString().Split('.'), new ReflectNamespace() { Assembly = newassembly, Name = namespaceList.ToString(), Types = new Dictionary <string, Lazy <ReflectType> >() }); } } } } else { newNamesspace = newCtx.Namespaces.GetValue(type.Namespace.Split('.')); } // Adds to List if (!newNamesspace.Types.ContainsKey(type.Name)) { var reflectionType = type; newNamesspace.Types.Add(type.Name, new Lazy <ReflectType>(() => AddNewReflectType(reflectionType, newassembly, newNamesspace))); } } } } }
private static void FillConstructors(Type type, ReflectType newType, ReflectAssembly newassembly, ReflectNamespace currNamespace) { foreach (var constructorInfo in type.GetConstructors()) { var newMethod = new ReflectMethod() { Name = constructorInfo.Name, Parameters = new List <ReflectParameter>(), Return = null }; foreach (var parameterInfo in constructorInfo.GetParameters()) { Tuple <ReflectNamespace, ReflectAssembly> asmns2 = FindNamespaceAndAssembly(parameterInfo.ParameterType); newMethod.Parameters.Add(new ReflectParameter() { Name = parameterInfo.Name, Type = AddNewSimpleReflectType(parameterInfo.ParameterType, asmns2.Item2, asmns2.Item1) }); } newType.Contructors.Add(newMethod); } }
private static void FillMethods(Type type, ReflectType newType, ReflectAssembly newassembly, ReflectNamespace currNamespace) { foreach (var methodInfo in type.GetMethods()) { // Finds or crates a new Type on this assembly Tuple <ReflectNamespace, ReflectAssembly> asmns = FindNamespaceAndAssembly(methodInfo.ReturnType); var newMethod = new ReflectMethod() { Name = methodInfo.Name, Parameters = new List <ReflectParameter>(), Return = AddNewSimpleReflectType(methodInfo.ReturnType, asmns.Item2, asmns.Item1) }; foreach (var parameterInfo in methodInfo.GetParameters()) { Tuple <ReflectNamespace, ReflectAssembly> asmns2 = FindNamespaceAndAssembly(parameterInfo.ParameterType); newMethod.Parameters.Add(new ReflectParameter() { Name = parameterInfo.Name, Type = AddNewSimpleReflectType(parameterInfo.ParameterType, asmns2.Item2, asmns2.Item1) }); } newType.Methods.Add(newMethod); } }
private static void FillFields(Type type, ReflectType newType, ReflectAssembly newassembly, ReflectNamespace currNamespace) { foreach (var fieldInfo in type.GetFields()) { // Finds or crates a new Type on this assembly Tuple <ReflectNamespace, ReflectAssembly> asmns = FindNamespaceAndAssembly(fieldInfo.FieldType); newType.Fields.Add(new ReflectField() { Name = fieldInfo.Name, Type = AddNewSimpleReflectType(fieldInfo.FieldType, asmns.Item2, asmns.Item1) }); } }
private static void FillProperties(Type type, ReflectType newType, ReflectAssembly newassembly, ReflectNamespace currNamespace) { foreach (var propertyInfo in type.GetProperties()) { // Finds or crates a new Type on this assembly Tuple <ReflectNamespace, ReflectAssembly> asmns = FindNamespaceAndAssembly(propertyInfo.PropertyType); newType.Properties.Add(new ReflectProperty() { Name = propertyInfo.Name, Type = AddNewSimpleReflectType(propertyInfo.PropertyType, asmns.Item2, asmns.Item1) }); } }
private static ReflectType AddNewReflectType(Type type, ReflectAssembly newassembly, ReflectNamespace currNamespace) { var newType = new ReflectType() { Name = type.Name, FullName = type.FullName, Namespace = currNamespace, Assembly = newassembly, Contructors = new List <ReflectMethod>(), Methods = new List <ReflectMethod>(), Fields = new List <ReflectField>(), Properties = new List <ReflectProperty>(), Events = new List <ReflectEvent>(), CSharpName = ToGenericTypeString(type) }; FillConstructors(type, newType, newassembly, currNamespace); FillMethods(type, newType, newassembly, currNamespace); FillFields(type, newType, newassembly, currNamespace); FillProperties(type, newType, newassembly, currNamespace); FillEvents(type, newType); return(newType); }