public LoadedTypeManager(string[] slookfolders, Type lookfor, IEnumerable <string> ignoreassemblynames, iManagerCallback pcallback) { //alright, iterate through all the folders.. mcallback = pcallback; TypeManage = lookfor; DirectoryInfo[] lookfolders = new DirectoryInfo[slookfolders.Length]; for (int i = 0; i < slookfolders.Length; i++) { lookfolders[i] = new DirectoryInfo(slookfolders[i]); } List <Assembly> AssemblyList = new List <Assembly>(); foreach (DirectoryInfo loopfolder in lookfolders) { //now iterate through all the DLL files in that folder. if (loopfolder.Exists) { foreach (FileInfo dllfile in loopfolder.GetFiles("*.dll", SearchOption.TopDirectoryOnly)) { Assembly LoadAssembly = null; //attempt to load this as an assembly... try { LoadAssembly = Assembly.LoadFile(dllfile.FullName); mcallback.ShowMessage("Loaded Assembly:" + dllfile.Name); } catch (Exception error) { mcallback.ShowMessage("Load of " + dllfile.Name + " failed- " + error.Message); } if (LoadAssembly != null) { if ( !ignoreassemblynames.Any <String> ( (y) => y.Equals(LoadAssembly.GetName().Name, StringComparison.OrdinalIgnoreCase))) { AssemblyList.Add(LoadAssembly); } } } } } mcallback.ShowMessage("Found " + AssemblyList.Count.ToString() + " Assemblies."); AssemblyList.Add(Assembly.GetExecutingAssembly()); //add this assembly, so it can find the default builder. LoadTypes(AssemblyList.ToArray()); //LoadTypeScores(ManagedTypes.ToArray(), mcallback); }
private void LoadTypes(Assembly[] useassemblies, IEnumerable <String> ignoreassemblies) { //strip duplicates first. //Notice: this code is mostly dead! consult MultiTypeManager... if (ignoreassemblies == null) { ignoreassemblies = new String[] { "" } } ; useassemblies = RemoveDuplicates <Assembly>(useassemblies.ToList()).ToArray(); foreach (var LoadAssembly in useassemblies) { int CountInFile = 0; Assembly assembly = LoadAssembly; //prevent access to local closure if (assembly.GetName().Name.Equals("script_testscript", StringComparison.OrdinalIgnoreCase)) { Debug.Print("test"); } if ((!assembly.GetName().Name.StartsWith("script_", StringComparison.OrdinalIgnoreCase)) && ignoreassemblies.Any((y) => y.TestRegex(assembly.GetName().Name))) { mcallback.ShowMessage("Skipping Assembly:" + LoadAssembly.GetName().Name); } else { mcallback.ShowMessage("Inspecting Assembly:" + LoadAssembly.GetName().Name); try { foreach (Type looptype in LoadAssembly.GetTypes()) { CountInFile += CheckType(looptype) ? 1 : 0; } } catch (ReflectionTypeLoadException rtle) { mcallback.ShowMessage("ReflectionTypeLoadException occured;" + rtle.StackTrace + " InnerExceptions:"); foreach (Exception loopexception in rtle.LoaderExceptions) { mcallback.ShowMessage("RTLE Loader Exception:" + loopexception.Message + " Source:" + loopexception.Source + "stack Trace:" + loopexception.StackTrace); } mcallback.ShowMessage("End of RTLE Loader Exceptions"); } catch (Exception ex) { mcallback.ShowMessage(ex.Message + " stack:" + ex.StackTrace); } } mcallback.ShowMessage("Found " + CountInFile.ToString() + " " + TypeManage.Name + " Implementations in " + LoadAssembly.GetName()); foreach (Type looptype in ManagedTypes) { mcallback.ShowMessage(TypeManage.Name + " Implemented by:" + looptype.Name); } } mcallback.ShowMessage("Assembly enumeration complete. Removing duplicates..."); _ManagedTypes = RemoveDuplicates(_ManagedTypes, mcallback); }
public static Assembly[] AssembliesFromStrings(String[] foldernames, iManagerCallback datahook) { List <Assembly> buildlist = new List <Assembly>(); buildlist.Add(Assembly.GetExecutingAssembly()); foreach (String loopfolder in foldernames) { if (Directory.Exists(loopfolder)) { foreach (FileInfo loopfile in new DirectoryInfo(loopfolder).GetFiles("*.dll", SearchOption.TopDirectoryOnly)) { Assembly testassembly; try { testassembly = Assembly.LoadFile(loopfile.FullName); if (testassembly != null) { buildlist.Add(testassembly); } } catch (Exception err) { //Debug.Print("failed to load assembly:" + loopfile.FullName + " " + err.Message); datahook.ShowMessage("failed to load assembly:" + loopfile.FullName + " " + err.Message); } } } } return(buildlist.ToArray()); }
public static bool CheckType(Type looptype, Type TypeManage, iManagerCallback mcallback) { int CountInFile = 0; //if (BCBlockGameState.Verbose) mcallback.ShowMessage("checking:" + looptype.Name); if (!looptype.IsAbstract) { //added more recently: check wether it is a class derived from the given type. if (looptype.IsSubclassOf(TypeManage)) { mcallback.ShowMessage("Found " + TypeManage.Name + " Derivation:" + looptype.Name); //ManagedTypes.Add(looptype); CountInFile++; //break out of the immediate loop. } else { foreach (var loopinterface in looptype.GetInterfaces()) { try { if (loopinterface.Equals(TypeManage)) { mcallback.ShowMessage("Found " + TypeManage.Name + " Implementor:" + looptype.Name); //ManagedTypes.Add(looptype); CountInFile++; //break out of the immediate loop. break; } } catch (Exception ex) { Debug.Print("Exception:" + ex.Message); } } } } else { Debug.Print("Skipped Abstract class:" + looptype.FullName); } return(CountInFile > 0); }
public void LoadTemplates(DirectoryInfo Directory, iManagerCallback callback) { //load all .blf files from the given folder. DirectoryInfo di = Directory; callback.ShowMessage("Loading Templates from " + Directory); //iterate... foreach (FileInfo blffile in di.GetFiles("*.blf")) { try { TemplateSetData tsd = new TemplateSetData(blffile.FullName); LoadedTemplates.Add(tsd.Name, tsd); } catch (Exception exx) { callback.ShowMessage("Failed to load template data from " + blffile.FullName + " Exception:" + exx); } } }
private List <T> RemoveDuplicates <T>(List <T> removefrom, iManagerCallback mcallback) { Dictionary <T, T> Dictcheck = new Dictionary <T, T>(); foreach (T item in removefrom) { if (!Dictcheck.ContainsKey(item)) { Dictcheck.Add(item, item); } else { mcallback.ShowMessage("removing duplicate entry for " + item.ToString()); } } return(Dictcheck.Keys.ToList()); }
internal static IEnumerable <T> RemoveDuplicates <T>(IEnumerable <T> removefrom, iManagerCallback mcallback) { Dictionary <T, T> Dictcheck = new Dictionary <T, T>(); foreach (T item in removefrom) { if (item != null) { if (!Dictcheck.ContainsKey(item)) { Dictcheck.Add(item, item); yield return(item); } else { mcallback.ShowMessage("removing duplicate entry for " + item.ToString()); } } } }
public void ShowMessage(string message) { filelogwriter.ShowMessage(message); if (txtprogress.InvokeRequired) { txtprogress.Invoke((MethodInvoker)(() => { txtprogress.Text += Environment.NewLine + message; txtprogress.SelectionStart = txtprogress.Text.Length; txtprogress.ScrollToCaret(); })); } else { { txtprogress.Text += "\n" + message; txtprogress.ScrollToCaret(); } } #endregion }
public static IEnumerable <Assembly> AssembliesFromStrings(IEnumerable <String> foldernames, iManagerCallback datahook) { yield return(Assembly.GetExecutingAssembly()); foreach (String loopfolder in foldernames) { if (Directory.Exists(loopfolder)) { foreach ( FileInfo loopfile in new DirectoryInfo(loopfolder).GetFiles("*.dll", SearchOption.TopDirectoryOnly)) { Assembly testassembly = null; try { if (loopfile.FullName.EndsWith("DragonAdapter.dll", StringComparison.OrdinalIgnoreCase)) { Debug.Print("Dragon"); } testassembly = Assembly.LoadFile(loopfile.FullName); } catch (Exception err) { //Debug.Print("failed to load assembly:" + loopfile.FullName + " " + err.Message); datahook.ShowMessage("failed to load assembly:" + loopfile.FullName + " " + err.Message); } if (testassembly != null) { yield return(testassembly); } } } } }
public MultiTypeManager(Assembly[] lookassemblies, Type[] typesload, IEnumerable <String> IgnoreAssemblies, IEnumerable <String> IncludeAssemblies, iManagerCallback pcallback, TypeManagerLoadProgressCallback pprog, Assembly[] preloadedassemblies) { //each Type corresponds to a new LoadedTypeManager to load for that type. //LoadedTypeManager[] ltm = new LoadedTypeManager[typesload.Length]; //create the Dictionary first... if (IgnoreAssemblies == null) { IgnoreAssemblies = new String[] { } } ; List <Assembly> buildcheck = new List <Assembly>(); if (preloadedassemblies != null) { buildcheck.AddRange(preloadedassemblies); } buildcheck.AddRange(lookassemblies); Assembly[] checkassemblies = buildcheck.ToArray(); loadeddata = new Dictionary <Type, LoadedTypeManager>(); foreach (Type looptype in typesload) { LoadedTypeManager addtm = new LoadedTypeManager(looptype, pcallback); 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 ((loopassembly.GetName().Name.StartsWith("script_", StringComparison.OrdinalIgnoreCase)) || (!IgnoreAssemblies.Any((w) => loopassembly.GetName().Name.TestRegex(w)))) { 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; if (pprog != null) { 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; // 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... 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); } } } }
public static bool CheckType(Type looptype, Type TypeManage, iManagerCallback mcallback) { if (looptype == null || TypeManage == null) { return(false); } int CountInFile = 0; if (!looptype.IsAbstract) { //if this is the type we want already, then we add it. //Seems a class cannot be a "Subclass" of itself. Realistically if the Type we are looking for is itself //instantiable we want to include it. if (looptype == TypeManage) { return(true); } //added more recently: check wether it is a class derived from the given type. if (looptype.IsSubclassOf(TypeManage)) { mcallback.ShowMessage ("Found " + TypeManage.Name + " Derivation:" + looptype.Name); //ManagedTypes.Add(looptype); CountInFile++; //break out of the immediate loop. } else { foreach (var loopinterface in looptype.GetInterfaces()) { try { if (loopinterface.Equals(TypeManage)) { mcallback.ShowMessage ("Found " + TypeManage.Name + " Implementor:" + looptype.Name); //ManagedTypes.Add(looptype); CountInFile++; //break out of the immediate loop. break; } } catch (Exception ex) { Debug.Print("Exception:" + ex.Message); } } } } else { // Debug.Print("Skipped Abstract class:" + looptype.FullName); } return(CountInFile > 0); }
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); } } }