public static List <Type> GetTypesFromAssembly(Assembly lookassembly, Type derivedFrom) { LoadedTypeManager ltm = new LoadedTypeManager(new Assembly[] { lookassembly }, derivedFrom, new Nullcallback()); ltm.LoadTypes(new Assembly[] { lookassembly }); return(ltm.ManagedTypes); }
public MultiTypeManager(IEnumerable <Assembly> lookassemblies, IEnumerable <Type> typesload, iManagerCallback pcallback, AssemblyLoadTestFunction TestAssembly, TypeManagerLoadProgressCallback pprog, LoadedTypeManager.TypeManagerInspectTypeCallback pinspectioncallback, IEnumerable <Assembly> preloadedassemblies) { lookassemblies = LoadedTypeManager.RemoveDuplicates(lookassemblies, pcallback).AsParallel(); //each Type corresponds to a new LoadedTypeManager to load for that type. //LoadedTypeManager[] ltm = new LoadedTypeManager[typesload.Length]; if (TestAssembly == null) { TestAssembly = ass => true; } //create the Dictionary first... inspectioncallback = pinspectioncallback; List <Assembly> buildcheck = new List <Assembly>(); if (preloadedassemblies != null) { foreach (var addassembly in preloadedassemblies) { if (!buildcheck.Contains(addassembly)) { buildcheck.Add(addassembly); } } } if (lookassemblies != null) { foreach (var addassembly in lookassemblies) { if (!buildcheck.Contains(addassembly)) { buildcheck.Add(addassembly); } } } Assembly[] checkassemblies = buildcheck.ToArray(); useassemblies = checkassemblies; loadeddata = new Dictionary <Type, LoadedTypeManager>(); foreach (Type looptype in typesload) { // LoadedTypeManager addtm = new LoadedTypeManager(checkassemblies,looptype, IgnoreAssemblies,pcallback); LoadedTypeManager addtm = new LoadedTypeManager(looptype); addtm.inspectioncallback = inspectioncallback; loadeddata.Add(looptype, addtm); } //now that we have the LoadedTypeManager objects, uninitialized- we can iterate through each assembly and the types //in each assembly for matches. //assemblyprogressincrement: the amount of progress we will go through after checking each assembly. float assemblyprogressincrement = 1f / (float)checkassemblies.Count(); float currprogress = 0; foreach (Assembly loopassembly in checkassemblies) { if (TestAssembly(loopassembly)) { pcallback.ShowMessage("Inspecting Assembly:" + loopassembly.GetName().Name); //iterate through each type... currprogress += assemblyprogressincrement; Type[] typesiterate; try { typesiterate = loopassembly.GetTypes(); } catch (ReflectionTypeLoadException rtle) { pcallback.ShowMessage ("ReflectionTypeLoadException occured;" + rtle.StackTrace + " InnerExceptions:"); foreach (Exception loopexception in rtle.LoaderExceptions) { pcallback.ShowMessage ("RTLE Loader Exception:" + loopexception.Message + " Source:" + loopexception.Source + "stack Trace:" + loopexception.StackTrace); } pcallback.ShowMessage("End of RTLE Loader Exceptions"); currprogress += assemblyprogressincrement; pprog(currprogress); typesiterate = null; } if (typesiterate != null) { //iterate through each type... //get appropriate percent per type... // float percentpertype = assemblyprogressincrement / typesiterate.Length; foreach (Type looptype in typesiterate) { //currprogress+=percentpertype; //if this is a class type... // pcallback.ShowMessage("Checking type:" + looptype.FullName); //And... for each type, iterate through all the LoadedTypeManagers in our dictionary... foreach (var checkmanager in loadeddata) { if (LoadedTypeManager.CheckType(looptype, checkmanager.Key, pcallback)) { pcallback.ShowMessage ("Type:" + looptype.FullName + " is a, or implements, " + checkmanager.Key.Name); //add it to that manager... if (inspectioncallback != null) { inspectioncallback(looptype); } if (looptype != null) { checkmanager.Value.ManagedTypes.Add(looptype); } } } } } } else { currprogress += assemblyprogressincrement; pprog(currprogress); pcallback.ShowMessage("Skipped Assembly " + loopassembly.FullName); } } //at the conclusion of the loop, show a summary. if (!(pcallback is Nullcallback)) { pcallback.ShowMessage ("Assembly enumeration complete.(" + checkassemblies.Count().ToString() + " Assemblies "); //^save time by not doing this for a Nullcallback... foreach (var loopltm in loadeddata) { pcallback.ShowMessage (" found " + loopltm.Value.ManagedTypes.Count + " instances of type " + loopltm.Key.Name); } } }