private void AddInjectionAssembly(string assemblyName)
{
ReflectionAssemblyResolver assemblyInjectionCode = null;
if (CacheStore.Exists <ReflectionAssemblyResolver>("injection|" + assemblyName))
{
assemblyInjectionCode = CacheStore.Get <ReflectionAssemblyResolver>("injection|" + assemblyName);
}
else
{
assemblyInjectionCode = new ReflectionAssemblyResolver(assemblyName);
CacheStore.Add <ReflectionAssemblyResolver>("injection|" + assemblyName, assemblyInjectionCode);
}
var nodeAssembly = new TreeNode {
Text = Path.GetFileName(assemblyName), Tag = assemblyInjectionCode
};
List <Type> types = assemblyInjectionCode.FindTypes <ICInject>();
for (int i = 0; i < types.Count; i++)
{
OnBindInjectors(assemblyInjectionCode, types[i], nodeAssembly, true);
}
// don't show the assembly if it does not have any injectors
if (types.Count > 0)
{
_rootInjection.Nodes.Add(nodeAssembly);
treeInjectionCode.ExpandAll();
}
_injectorAssemblyLoaded = true;
SendMessageToPlugins(EventType.InjectionAssemblyLoaded, null, null, assemblyName);
}
private void AddTargetAssembly(string assemblyName)
{
MonoAssemblyResolver assemblyTarget = null;
if (CacheStore.Exists <MonoAssemblyResolver>("mono|" + assemblyName))
{
assemblyTarget = CacheStore.Get <MonoAssemblyResolver>("mono|" + assemblyName);
}
else
{
assemblyTarget = new MonoAssemblyResolver(assemblyName);
CacheStore.Add <MonoAssemblyResolver>("mono|" + assemblyName, assemblyTarget);
}
// add in the dictionary
if (_targetAssemblies.ContainsKey(assemblyName) == false)
{
_targetAssemblies.Add(assemblyName, assemblyTarget);
}
// attach message received event
assemblyTarget.OnMessageReceived += resolver_OnMessageReceived;
// add node
var nodeAssembly = new TreeNode
{
Text = Path.GetFileName(assemblyName),
Tag = new BindItem {
Assembly = assemblyTarget, Method = null
}
};
_rootTarget.Nodes.Add(nodeAssembly);
List <TypeDefinition> types = assemblyTarget.FindClasses();
for (int i = 0; i < types.Count; i++)
{
if (types[i].HasMethods)
{
var nodeClass = new TreeNode
{
Text = types[i].Name,
Tag = types[i]
};
nodeAssembly.Nodes.Add(nodeClass);
OnBindMethodsDefinitions(assemblyTarget, types[i], nodeClass);
}
}
treeTarget.CollapseAll();
_targetAssemblyLoaded = true;
SendMessageToPlugins(EventType.TargetAssemblyLoaded, null, null, assemblyName);
}
internal static InjectionMapping FromProjectInjectionMapping(ProjectInjectionMapping projMapping)
{
MonoAssemblyResolver targetAssembly = null;
TypeDefinition type = null;
MethodDefinition method = null;
Type injector = null;
if (CacheStore.Exists <MonoAssemblyResolver>(projMapping.TargetAssemblyPath))
{
targetAssembly = CacheStore.Get <MonoAssemblyResolver>(projMapping.TargetAssemblyPath);
}
else
{
targetAssembly = new MonoAssemblyResolver(projMapping.TargetAssemblyPath);
CacheStore.Add <MonoAssemblyResolver>(projMapping.TargetAssemblyPath, targetAssembly);
}
string classNameKey = targetAssembly.Assembly.Name.Name + "." + projMapping.ClassName;
if (CacheStore.Exists <TypeDefinition>(classNameKey))
{
type = CacheStore.Get <TypeDefinition>(classNameKey);
}
else
{
type = targetAssembly.Assembly.MainModule.GetType(classNameKey);
CacheStore.Add <TypeDefinition>(classNameKey, type);
}
if (CacheStore.Exists <MethodDefinition>(classNameKey + projMapping.MethodName))
{
method = CacheStore.Get <MethodDefinition>(classNameKey + projMapping.MethodName);
}
else
{
method = type.GetMethodDefinition(projMapping.MethodName, projMapping.MethodParameters);
CacheStore.Add <MethodDefinition>(classNameKey + projMapping.MethodName, method);
}
if (CacheStore.Exists <Type>(projMapping.InjectorType))
{
injector = CacheStore.Get <Type>(projMapping.InjectorType);
}
else
{
injector = Type.GetType(projMapping.InjectorType);
CacheStore.Add <Type>(projMapping.InjectorType, injector);
}
return(new InjectionMapping(targetAssembly, method, injector));
}
