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 TemplateManager(IEnumerable<DirectoryInfo> Dirinfos, iManagerCallback callback)
{
foreach (DirectoryInfo loopdir in Dirinfos)
{
LoadTemplates(loopdir, callback);
}
}
public LoadedTypeManager(Assembly[] lookassemblies, Type lookfor, IEnumerable <string> ignoreassemblynames,
iManagerCallback pcallback, TypeManagerInspectTypeCallback pinspectioncallback)
{
TypeManage = lookfor;
this.inspectioncallback = pinspectioncallback;
LoadTypes(lookassemblies, ignoreassemblynames);
//LoadTypeScores(ManagedTypes.ToArray(), mcallback);
}
public static void GameInitialize(iManagerCallback datahook)
{
OrbImages = new Image[PrebuiltOrbImageCount];
for(int i=0;i<PrebuiltOrbImageCount;i++)
{
OrbImages[i] = DrawOrbBlockImage();
}
}
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 DoInit()
{
try
{
logfilename = Path.Combine(BCBlockGameState.AppDataFolder, "baseblock.log");
filelogwriter = new FileLogCallback(logfilename);
}
catch
{
}
}
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());
}
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);
}
}
}
private void DoInit()
{
try
{
logfilename = Path.Combine(BCBlockGameState.AppDataFolder, "baseblock.log");
filelogwriter = new FileLogCallback(logfilename);
}
catch
{
}
}
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);
}
}
}
}
}
/// <summary>
/// Directly initializes a LoadedTypeManager instance with a specified list of managed types and the Type being managed.
/// </summary>
/// <param name="pTypeManage"></param>
/// <param name="pmanagedtypes"></param>
/// <param name="pcallback"></param>
internal LoadedTypeManager(Type pTypeManage, IEnumerable <Type> pmanagedtypes, iManagerCallback pcallback)
{
TypeManage = pTypeManage;
ManagedTypes = pmanagedtypes.ToList();
mcallback = pcallback;
}
public void LoadTemplates(String Directory, iManagerCallback callback)
{
LoadTemplates(new DirectoryInfo(Directory), callback);
}
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());
}
}
}
}
/// <summary>
/// Internal constructor used to create a LoadedTypeManager that has no actual state. This is used by the MultiTypeManager class
/// to create "empty" TypeManager instances that it can then add to.
/// </summary>
/// <param name="ptypemanage"></param>
/// <param name="pcallback"></param>
internal LoadedTypeManager(Type ptypemanage, iManagerCallback pcallback)
{
TypeManage = ptypemanage;
mcallback = pcallback;
}
public LoadedTypeManager(Assembly[] lookassemblies, Type lookfor, iManagerCallback pcallback)
: this(lookassemblies, lookfor, null, pcallback)
{
}
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 MultiTypeManager(String[] lookfolders, Type[] typesload,
iManagerCallback pcallback, AssemblyLoadTestFunction TestAssembly,
TypeManagerLoadProgressCallback pp, Assembly[] preloadedassemblies)
: this(AssembliesFromStrings(lookfolders), typesload, pcallback, TestAssembly, pp, preloadedassemblies)
{
}
public MultiTypeManager(Assembly[] checkassemblies, Type[] typesload, IEnumerable <String> IgnoreAssemblies, iManagerCallback pcallback, TypeManagerLoadProgressCallback pprog, Assembly[] preloadedassemblies)
: this(checkassemblies, typesload, IgnoreAssemblies, new List <String>(), pcallback, pprog, preloadedassemblies)
{
}
public MultiTypeManager(String[] lookfolders, Type[] typesload, IEnumerable <String> IgnoreAssemblies,
iManagerCallback pcallback, TypeManagerLoadProgressCallback pp, Assembly[] preloadedassemblies)
: this(AssembliesFromStrings(lookfolders), typesload, IgnoreAssemblies, pcallback, pp, preloadedassemblies)
{
}
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 TemplateManager(IEnumerable<String> Directories, iManagerCallback callback)
: this((from p in Directories select new DirectoryInfo(p)), callback)
{
}
/// <summary>
/// Directly initializes a LoadedTypeManager instance with a specified list of managed types and the Type being managed.
/// </summary>
/// <param name="pTypeManage"></param>
/// <param name="pmanagedtypes"></param>
/// <param name="pcallback"></param>
internal LoadedTypeManager(Type pTypeManage, Type[] pmanagedtypes, iManagerCallback pcallback)
{
TypeManage = pTypeManage;
ManagedTypes = pmanagedtypes.ToList();
mcallback = pcallback;
}
public MultiTypeManager(IEnumerable <Assembly> lookassemblies, IEnumerable <Type> typesload,
iManagerCallback pcallback, AssemblyLoadTestFunction TestAssembly,
TypeManagerLoadProgressCallback pprog, IEnumerable <Assembly> preloadedassemblies)
: this(lookassemblies, typesload, pcallback, TestAssembly, pprog, null, preloadedassemblies)
{
}
public LoadedTypeManager(string[] slookfolders, Type lookfor, iManagerCallback pcallback)
: this(slookfolders, lookfor, new String[] { }, pcallback)
{
}
public LoadedTypeManager(String lookfolder, Type lookfor, iManagerCallback pcallback)
: this(new string[] { lookfolder }, lookfor, pcallback)
{
}
public LoadedTypeManager(Assembly[] lookassemblies, Type lookfor, IEnumerable <string> ignoreassemblynames,
iManagerCallback pcallback)
: this(lookassemblies, lookfor, ignoreassemblynames, pcallback, null)
{
}