/// <summary>
/// Parses an object based on a .NET type definition
/// </summary>
/// <param name="type"></param>
/// <param name="dontParseMembers"></param>
/// <returns></returns>
public DotnetObject ParseObject(Type type, bool dontParseMembers = false)
{
var resolver = new MonoAssemblyResolver();
var a = AssemblyDefinition.ReadAssembly(type.Assembly.Location,
new ReaderParameters()
{
AssemblyResolver = resolver
});
resolver.AssemblyDefinition = a;
var tr = a.MainModule.Import(type: type);
var td = tr.Resolve();
if (td == null)
{
SetError("Couldn't resolve .NET Type: " + type.FullName);
return(null);
}
if (string.IsNullOrEmpty(AssemblyFilename))
{
AssemblyFilename = type.Assembly.Location;
}
return(ParseObject(td, dontParseMembers));
}
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);
}
public InjectionMapping(MonoAssemblyResolver assembly,
MethodDefinition method, Type injector)
{
Assembly = assembly;
Method = method;
Injector = injector;
MethodName = method.Name;
InjectorName = injector.FullName;
AssemblyName = assembly.Assembly.FullName;
}
public InjectionMapping(MonoAssemblyResolver assembly,
MethodDefinition method, Type injector)
{
Assembly = assembly;
Method = method;
Injector = injector;
MethodName = method.Name;
InjectorName = injector.FullName;
AssemblyName = assembly.Assembly.FullName;
}
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));
}
private void OnBindMethodsDefinitions(MonoAssemblyResolver assemblyTarget, TypeDefinition typeDefinition,
TreeNode rootNode)
{
var methodDefinitions = typeDefinition.GetMethods(false);
for (int i = 0; i < methodDefinitions.Count; i++)
{
var node = new TreeNode
{
Text =
string.Format("{0} ({1})", methodDefinitions[i].Name,
methodDefinitions[i].Parameters.Count),
Tag = new BindItem {
Method = methodDefinitions[i], Assembly = assemblyTarget
}
};
rootNode.Nodes.Add(node);
}
}
private void OnBindMethodsDefinitions(MonoAssemblyResolver assemblyTarget, TypeDefinition typeDefinition,
TreeNode rootNode)
{
var methodDefinitions = typeDefinition.GetMethods(false);
for (int i = 0; i < methodDefinitions.Count; i++)
{
var node = new TreeNode
{
Text =
string.Format("{0} ({1})", methodDefinitions[i].Name,
methodDefinitions[i].Parameters.Count),
Tag = new BindItem { Method = methodDefinitions[i], Assembly = assemblyTarget }
};
rootNode.Nodes.Add(node);
}
}
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);
}
private static void LoadTarget()
{
try
{
var path = AppDomain.CurrentDomain.BaseDirectory + "descriptors.txt";
if (File.Exists(path))
{
var descriptors = File.ReadAllText(path, Encoding.UTF8);
foreach (var assemblyName in descriptors.Split(';'))
{
var files = Directory.GetFiles(Environment.CurrentDirectory, assemblyName);
if (files.Length <= 0)
{
continue;
}
//assembly
var assemblyTarget = new MonoAssemblyResolver(assemblyName);
var text = Path.GetFileName(assemblyName);
var tag = new BindItem {
Assembly = assemblyTarget, Method = null
};
//class
List <TypeDefinition> types = assemblyTarget.FindClasses();
for (int i = 0; i < types.Count; i++)
{
if (types[i].HasMethods)
{
//method
var methodDefinitions = types[i].GetMethods(false);
for (int j = 0; j < methodDefinitions.Count; j++)
{
Type type = null;
if (types[i].Name == "Program" && methodDefinitions[j].Name == "Main")
{
type = _injectTypeDict["Startup"];
}
else
{
type = _injectTypeDict["ObjectValueInject"];
}
_mapping.Add(new InjectionMapping(assemblyTarget, methodDefinitions[j], type));
}
}
}
}
}
else
{
Console.WriteLine($"{path}文件不存在");
}
}
catch (Exception ex)
{
throw ex;
}
}
private void LoadInject()
{
_mapping = new List <InjectionMapping>();
var directory = Path.GetDirectoryName(Application.ExecutablePath);
Type type = null;
MethodDefinition Method = null;
MonoAssemblyResolver Assembly = null;
if (directory != null)
{
var files = Directory.GetFiles(directory, "CInject.Injections.dll");
foreach (var assemblyName in files)
{
var assemblyInjectionCode = new ReflectionAssemblyResolver(assemblyName);
//取值 type
foreach (Type t in assemblyInjectionCode.Assembly.GetTypes())
{
if (t.Name.ToString() == "Startup")
{
type = t;
}
;
}
}
var filess = Directory.GetFiles(directory, "CInject.SampleWinform.exe");
foreach (var assemblyName in files)
{
MonoAssemblyResolver assemblyTarget = new MonoAssemblyResolver(assemblyName);
// 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)
{
if (types[i].Name == "Program")
{
var methodDefinitions = types[i].GetMethods(false);
for (int j = 0; j < methodDefinitions.Count; j++)
{
if (methodDefinitions[i].Name == "Main")
{
Method = methodDefinitions[i];
Assembly = assemblyTarget;
}
}
}
}
}
}
_mapping.Add(new InjectionMapping(Assembly, Method, type));
}
}
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);
}
