public static DynaClassInfo GetClassReference(string AssemblyName, string ClassName)
{
if (ClassReferences.ContainsKey(AssemblyName) == false)
{
Assembly assembly;
if (AssemblyReferences.ContainsKey(AssemblyName) == false)
{
AssemblyReferences.Add(AssemblyName,
assembly = Assembly.LoadFrom(AssemblyName));
}
else
assembly = (Assembly)AssemblyReferences[AssemblyName];
// Walk through each type in the assembly
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass == true)
{
// doing it this way means that you don't have
// to specify the full namespace and class (just the class)
if (type.FullName.EndsWith("." + ClassName))
{
DynaClassInfo ci = new DynaClassInfo(type,
Activator.CreateInstance(type));
ClassReferences.Add(AssemblyName, ci);
return (ci);
}
}
}
throw (new System.Exception("could not instantiate class"));
}
return ((DynaClassInfo)ClassReferences[AssemblyName]);
}
public static DynaClassInfo GetClassReference(string AssemblyName, string ClassName)
{
Assembly assembly;
if (ClassReferences.ContainsKey(AssemblyName))
{
return((DynaClassInfo)ClassReferences[AssemblyName]);
}
if (!AssemblyReferences.ContainsKey(AssemblyName))
{
AssemblyReferences.Add(AssemblyName, assembly = Assembly.LoadFrom(AssemblyName));
}
else
{
assembly = (Assembly)AssemblyReferences[AssemblyName];
}
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass && type.FullName.EndsWith("." + ClassName))
{
DynaClassInfo info = new DynaClassInfo(type, Activator.CreateInstance(type));
ClassReferences.Add(AssemblyName, info);
return(info);
}
}
throw new Exception("could not instantiate class");
}
public static DynaClassInfo GetClassReference(string AssemblyName, string ClassName)
{
Assembly assembly;
if (ClassReferences.ContainsKey(AssemblyName))
{
return (DynaClassInfo)ClassReferences[AssemblyName];
}
if (!AssemblyReferences.ContainsKey(AssemblyName))
{
AssemblyReferences.Add(AssemblyName, assembly = Assembly.LoadFrom(AssemblyName));
}
else
{
assembly = (Assembly)AssemblyReferences[AssemblyName];
}
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass && type.FullName.EndsWith("." + ClassName))
{
DynaClassInfo info = new DynaClassInfo(type, Activator.CreateInstance(type));
ClassReferences.Add(AssemblyName, info);
return info;
}
}
throw new Exception("could not instantiate class");
}
GetClassReference(string AssemblyName, string ClassName)
{
if (ClassReferences.ContainsKey(AssemblyName) == false)
{
Assembly assembly;
if (AssemblyReferences.ContainsKey(AssemblyName) == false)
{
AssemblyReferences.Add(AssemblyName,
assembly = Assembly.LoadFrom(AssemblyName));
}
else
{
assembly = (Assembly)AssemblyReferences[AssemblyName];
}
// Walk through each type in the assembly
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass == true)
{
// doing it this way means that you don't have
// to specify the full namespace and class (just the class)
if (type.FullName.EndsWith("." + ClassName))
{
DynaClassInfo ci = new DynaClassInfo(type,
Activator.CreateInstance(type));
ClassReferences.Add(AssemblyName, ci);
return(ci);
}
}
}
throw (new System.Exception("could not instantiate class"));
}
return((DynaClassInfo)ClassReferences[AssemblyName]);
}
private static T SetProperty <T>(DynaClassInfo ci,
string PropName, T arg)
{
// Dynamically Invoke the method
PropertyInfo pi = ci.type.GetProperty(PropName);
//Type type = typeof(T);
Type ptype = pi.PropertyType;
if (ptype.IsGenericType && ptype.GetGenericArguments().Length > 0 && ptype.GetGenericArguments()[0].IsEnum)
{
// Convert Int32 to Enum?
TypeConverter convertSet = TypeDescriptor.GetConverter(pi.PropertyType);
pi.SetValue(ci.ClassObject, convertSet.ConvertFrom(arg.ToString() + ""), new Object[] { });
// Convert Enum? to Int32
TypeConverter convertGet = TypeDescriptor.GetConverter(typeof(T));
int tmp = (int)(pi.GetValue(ci.ClassObject, new Object[] { }));
return((T)convertGet.ConvertFrom(tmp.ToString() + ""));
}
else
{
pi.SetValue(ci.ClassObject, (T)arg, new Object[] { });
return((T)(pi.GetValue(ci.ClassObject, new Object[] { })));
}
}
// --- this is the method that you invoke ------------
public static Object InvokeMethod(string AssemblyName,
string ClassName, string MethodName, Object[] args)
{
DynaClassInfo ci = GetClassReference(AssemblyName, ClassName);
return(InvokeMethod(ci, MethodName, args));
}
public static Object InvokeMethod(DynaClassInfo ci,
string MethodName, Object[] args)
{
Object Result = ci.type.InvokeMember(MethodName,
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
ci.ClassObject,
args);
return (Result);
}
public static Object InvokeMethod(DynaClassInfo ci,
string MethodName, Object[] args)
{
Object Result = ci.type.InvokeMember(MethodName,
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
ci.ClassObject,
args);
return(Result);
}
private static T CallMethod <T>(DynaClassInfo ci,
string MethodName, Object[] mArgs)
{
// Dynamically Invoke the method
Object Result = ci.type.InvokeMember(MethodName,
BindingFlags.Default | BindingFlags.InvokeMethod,
null,
ci.ClassObject,
mArgs);
return((T)Result);
}
GetClassReference(string assemblyFullPath, string className, bool searchWithinCallingAssembly = true)
{
string assemblyClassName = assemblyFullPath + "." + className;
DynaClassInfo classInfo = null;
var assemblyName = Path.GetFileNameWithoutExtension(assemblyFullPath);
if (!ClassReferences.TryGetValue(assemblyClassName, out classInfo))
{
Assembly assembly = null;
if (searchWithinCallingAssembly)
{
var currAssembly = Assembly.GetExecutingAssembly();
var currAssemblyExistingClass = getClassInfo(currAssembly, className);
if (currAssemblyExistingClass != null)
{
assembly = currAssembly;
classInfo = currAssemblyExistingClass;
}
else
{
try
{
assembly = Assembly.Load(assemblyName);
}
catch (FileNotFoundException)
{
}
}
}
if (assembly == null)
{
if (AssemblyReferences.ContainsKey(assemblyFullPath) == false)
{
AssemblyReferences.Add(assemblyFullPath,
assembly = Assembly.LoadFrom(assemblyFullPath));
}
else
{
assembly = (Assembly)AssemblyReferences[assemblyFullPath];
}
}
classInfo = classInfo ?? getClassInfo(assembly, className);
if (classInfo == null)
{
throw new System.Exception("Could not instantiate class: " + className);
}
ClassReferences.Add(assemblyClassName, classInfo);
}
return(classInfo);
}
private static DynaClassInfo getClassInfo(Assembly assembly, string className)
{
var classNameSuffix = "." + className;
// Walk through each type in the assembly
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass == true && type.FullName.EndsWith(classNameSuffix))
{
var classInfo = new DynaClassInfo(type, Activator.CreateInstance(type));
return(classInfo);
}
}
return(null);
}
public static Object InvokeMethod(string AssemblyName,
string ClassName, string MethodName, Object[] args)
{
DynaClassInfo ci = GetClassReference(AssemblyName, ClassName);
if (ci == null)
{
Type type = Type.GetType(AssemblyName + "." + ClassName);
if (type != null)
{
ci = new DynaClassInfo(type, Activator.CreateInstance(type));
}
}
return(InvokeMethod(ci, MethodName, args));
}
private static T GetProperty <T>(DynaClassInfo ci,
string PropName)
{
// Dynamically Get a Property Value
PropertyInfo pi = ci.type.GetProperty(PropName);
Object value = pi.GetValue(ci.ClassObject, new Object[] { });
if (value != null)
{
return((T)(value));
}
return(default(T));
}
/// <summary>
/// Preload an Assembly
/// </summary>
/// <param name="AssemblyName">The Filename of the Assembly</param>
/// <param name="ClassName">The Classname to instantiate</param>
/// <param name="cArgs">Constructor Parameters (or null)</param>
/// <returns>true if succeeeded</returns>
public static Boolean PreLoadAssembly(string AssemblyName, string ClassName, Object[] cArgs = null)
{
if (ClassReferences.ContainsKey(AssemblyName) == false)
{
Assembly assembly;
if (AssemblyReferences.ContainsKey(AssemblyName) == false)
{
AssemblyReferences.Add(AssemblyName,
assembly = Assembly.LoadFrom(AssemblyName));
}
else
{
assembly = AssemblyReferences[AssemblyName];
}
// Walk through each type in the assembly
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass == true)
{
// Doing it this way means that you don't have
// to specify the full namespace and class (just the class)
if (type.FullName.EndsWith("." + ClassName))
{
try
{
DynaClassInfo ci = new DynaClassInfo(type,
Activator.CreateInstance(type, cArgs));
ClassReferences.Add(AssemblyName, ci);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
}
}
}
}
return(ClassReferences.ContainsKey(AssemblyName));
}
GetClassReference(string AssemblyName, string ClassName)
{
if (ClassReferences.ContainsKey(AssemblyName) == false)
{
Assembly assembly;
if (AssemblyReferences.ContainsKey(AssemblyName) == false)
{
try
{
AssemblyReferences.Add(AssemblyName,
assembly = Assembly.LoadFrom(AssemblyName));
}
catch
{
return(null);
}
}
else
{
assembly = (Assembly)AssemblyReferences[AssemblyName];
}
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass == true)
{
if (type.FullName.EndsWith("." + ClassName))
{
DynaClassInfo ci = new DynaClassInfo(type,
Activator.CreateInstance(type));
ClassReferences.Add(AssemblyName, ci);
return(ci);
}
}
}
}
return((DynaClassInfo)ClassReferences[AssemblyName]);
}
public static DynaClassInfo GetClassReference(string AssemblyName, string ClassName)
{
if (ClassReferences.ContainsKey(AssemblyName) == false)
{
Assembly assembly;
if (AssemblyReferences.ContainsKey(AssemblyName) == false)
{
try
{
AssemblyReferences.Add(AssemblyName,
assembly = Assembly.LoadFrom(AssemblyName));
}
catch
{
return null;
}
}
else
assembly = (Assembly)AssemblyReferences[AssemblyName];
foreach (Type type in assembly.GetTypes())
{
if (type.IsClass == true)
{
if (type.FullName.EndsWith("." + ClassName))
{
DynaClassInfo ci = new DynaClassInfo(type,
Activator.CreateInstance(type));
ClassReferences.Add(AssemblyName, ci);
return (ci);
}
}
}
}
return ((DynaClassInfo)ClassReferences[AssemblyName]);
}
public static object InvokeMethod(DynaClassInfo ci, string MethodName, object[] args)
{
return(ci.type.InvokeMember(MethodName, BindingFlags.InvokeMethod, null, ci.ClassObject, args));
}
// --- these is the method that you invoke ------------
/// <summary>
/// Call a Generic typed Method on an (cached) Assembly.
/// </summary>
/// <typeparam name="T">The return Type</typeparam>
/// <param name="AssemblyName">The Filename of the Assembly</param>
/// <param name="ClassName">The Classname to instantiate</param>
/// <param name="MethodName">The Method name to invoke</param>
/// <param name="mArgs">Method Parameters</param>
/// <param name="cArgs">Constructor Parameters (or null)</param>
/// <returns>The method result if any</returns>
public static T CallMethod <T>(String AssemblyName, String ClassName, String MethodName, Object[] mArgs, Object[] cArgs = null)
{
DynaClassInfo ci = GetClassReference(AssemblyName, ClassName, cArgs);
return(CallMethod <T>(ci, MethodName, mArgs));
}
/// <summary>
/// Call a Method on an (cached) Assembly.
/// </summary>
/// <param name="AssemblyName">The Filename of the Assembly</param>
/// <param name="ClassName">The Classname to instantiate</param>
/// <param name="MethodName">The Method name to invoke</param>
/// <param name="mArgs">Method Parameters</param>
/// <param name="cArgs">Constructor Parameters (or null)</param>
public static void CallMethod(String AssemblyName, String ClassName, String MethodName, Object[] mArgs, Object[] cArgs = null)
{
DynaClassInfo ci = GetClassReference(AssemblyName, ClassName, cArgs);
CallMethod <Object>(ci, MethodName, mArgs);
}
/// <summary>
/// Return a Property value of an (cached) Assembly.
/// </summary>
/// <typeparam name="T">The Property Type</typeparam>
/// <param name="AssemblyName">The Filename of the Assembly</param>
/// <param name="ClassName">The Classname to instantiate</param>
/// <param name="PropName">The Property to set</param>
/// <param name="cArgs">Constructor Parameters (or null)</param>
/// <returns>The Property Value</returns>
public static T GetProperty <T>(String AssemblyName, String ClassName, String PropName, Object[] cArgs = null)
{
DynaClassInfo ci = GetClassReference(AssemblyName, ClassName, cArgs);
return(GetProperty <T>(ci, PropName));
}
public static Object InvokeMethod(string AssemblyName,
string ClassName, string MethodName, Object[] args)
{
DynaClassInfo ci = GetClassReference(AssemblyName, ClassName);
if (ci == null)
{
Type type = Type.GetType(AssemblyName + "." + ClassName);
if (type != null)
ci = new DynaClassInfo(type, Activator.CreateInstance(type));
}
return (InvokeMethod(ci, MethodName, args));
}
public static object InvokeMethod(DynaClassInfo ci, string MethodName, object[] args)
{
return ci.type.InvokeMember(MethodName, BindingFlags.InvokeMethod, null, ci.ClassObject, args);
}
