public void Constructor1_AttributedComposablePartDefintion_ShouldProduceValidObject()
{
var definition = PartDefinitionFactory.CreateAttributed(typeof(MyExport));
var part = new ReflectionComposablePart(definition);
Assert.AreEqual(definition, part.Definition);
Assert.IsNotNull(part.Metadata);
Assert.IsFalse(part is IDisposable);
}
public void Constructor1_Object_ShouldProduceValidObject()
{
var part = new ReflectionComposablePart(PartDefinitionFactory.CreateAttributed(typeof(MyExport)), new MyExport());
}
private static ReflectionComposablePart ProcessReflectionComposablePartDefinition(ClrHeap heap, ulong part)
{
var rcp = new ReflectionComposablePart();
ulong creationInfoObj = ClrMdHelper.GetLastObjectInHierarchy(heap, part, HIERARCHY_ReflectionComposablePartDefinition_To_AttributedPartCreationInfo, 0);
ClrType creationInfoObjType = heap.GetObjectType(creationInfoObj);
rcp.TypeName = creationInfoObjType.GetRuntimeType(creationInfoObj)?.Name ?? creationInfoObjType.Name;
var importObjs = ClrMdHelper.GetLastObjectInHierarchyAsArray(heap, part, HIERARCHY_CreationInfo_To_ImportArray, 0, TYPE_ImportDefinitionArray);
foreach (var importDef in importObjs)
{
var importDefType = heap.GetObjectType(importDef);
var prodInfoDef = importDefType.GetFieldByName(ProductImportDefinition);
ulong imDef;
if (prodInfoDef != null)
{
imDef = (ulong)prodInfoDef.GetValue(importDef);
}
else
{
imDef = importDef;
}
string contract = ClrMdHelper.GetObjectAs <string>(heap, imDef, FIELD_ContractName);
string typeId = ClrMdHelper.GetObjectAs <string>(heap, imDef, FIELD_RequiredTypeIdentity);
rcp.Imports.Add(new ImportDefinition()
{
ContractName = contract, RequiredTypeIdentity = typeId
});
}
// Get ExportDefinition[]
ulong exportArrayObj = ClrMdHelper.GetObjectAs <ulong>(heap, part, FIELD_Exports);
if (exportArrayObj != 0)
{
List <ulong> exportObjs = ClrMdHelper.GetArrayItems(heap.GetObjectType(exportArrayObj), exportArrayObj);
foreach (var exportDef in exportObjs)
{
ulong attrExpDef = ClrMdHelper.GetObjectAs <ulong>(heap, exportDef, FIELD_ExportDefinition);
string contract = ClrMdHelper.GetObjectAs <string>(heap, attrExpDef, FIELD_ContractName);
ulong typeObj = ClrMdHelper.GetObjectAs <ulong>(heap, attrExpDef, FIELD_TypeIdentityType);
string typename = null;
if (typeObj == 0)
{
Console.WriteLine($"WARNING: Special export was found with no type identity (contract: {contract})");
typename = rcp.TypeName;
}
else
{
ClrType typeObjType = heap.GetObjectType(typeObj);
typename = typeObjType.GetRuntimeType(typeObj)?.Name ?? typeObjType.Name;
}
rcp.Exports.Add(new ExportDefinition()
{
ContractName = contract, TypeIdentity = typename
});
}
}
return(rcp);
}
private static void MergeResults(Dictionary <string, ReflectionComposablePart> container, ReflectionComposablePart rcp)
{
if (container.ContainsKey(rcp.TypeName))
{
var rcpInContainer = container[rcp.TypeName];
if (!rcpInContainer.IsCreated)
{
rcpInContainer.IsCreated = rcp.IsCreated;
}
var importsToAdd = new List <ImportDefinition>();
foreach (var import in rcp.Imports)
{
if (!rcpInContainer.Imports.Contains(import, ImportDefinitionComparer.Instance))
{
importsToAdd.Add(import);
}
}
if (importsToAdd.Any())
{
rcpInContainer.Imports.AddRange(importsToAdd);
}
var exportsToAdd = new List <ExportDefinition>();
foreach (var export in rcp.Exports)
{
if (!rcpInContainer.Exports.Contains(export, ExportDefinitionComparer.Instance))
{
exportsToAdd.Add(export);
}
}
if (exportsToAdd.Any())
{
rcpInContainer.Exports.AddRange(exportsToAdd);
}
}
else
{
container[rcp.TypeName] = rcp;
}
}
private static void DumpTypes(ClrHeap heap, ulong obj, string type)
{
Console.WriteLine($"Dumping CompositionContainer @{obj:X}");
// Check if custom ExportProviders are present
ulong providersFieldValue = ClrMdHelper.GetObjectAs <ulong>(heap, obj, FIELD_Providers);
if (providersFieldValue != 0)
{
ulong providerArrayObj = ClrMdHelper.GetObjectAs <ulong>(heap, providersFieldValue, FIELD_List);
List <ulong> providerObjs = ClrMdHelper.GetArrayItems(heap.GetObjectType(providerArrayObj), providerArrayObj);
if (providerObjs.Count > 0)
{
Console.WriteLine("WARNING: custom ExportProvider(s) were found:");
}
foreach (ulong provider in providerObjs)
{
ClrType itemType = heap.GetObjectType(provider);
Console.WriteLine($"\t{itemType.Name}");
}
}
var RESULT = new Dictionary <string, ReflectionComposablePart>();
// Check if there exists a PartExportProvider
ulong partExportProvider = ClrMdHelper.GetObjectAs <ulong>(heap, obj, FIELD_PartExportProvider);
if (partExportProvider != 0)
{
// Get ComposablePart[] from ComposablePartExportProvider
List <ulong> composableParts = ClrMdHelper.GetLastObjectInHierarchyAsArray(heap, partExportProvider, HIERARCHY_PartExportProvider_To_ComposableParts, 0, TYPE_ComposablePart);
foreach (var composablePart in composableParts)
{
string composablePartTypeName = heap.GetObjectType(composablePart).Name;
if (composablePartTypeName == TYPE_ReflectionComposablePart)
{
var rcpDef = ClrMdHelper.GetObjectAs <ulong>(heap, composablePart, FIELD_Definition);
var rcp = ProcessReflectionComposablePartDefinition(heap, rcpDef);
rcp.IsCreated = true;
MergeResults(RESULT, rcp);
}
else if (composablePartTypeName == TYPE_SingleExportComposablePart)
{
ulong export = ClrMdHelper.GetObjectAs <ulong>(heap, composablePart, FIELD_Export);
ulong exportedValue = ClrMdHelper.GetObjectAs <ulong>(heap, export, FIELD_ExportedValue);
string exportedValueTypeName = exportedValue != 0 ? heap.GetObjectType(exportedValue).Name : null;
bool isCached = exportedValue != 0 && exportedValueTypeName != typeof(object).FullName;
if (!isCached)
{
ulong realExportedValue = ClrMdHelper.GetLastObjectInHierarchy(heap, export, HIERARCHY_Func_To_ExportedValue, 0);
if (realExportedValue != 0)
{
exportedValueTypeName = heap.GetObjectType(realExportedValue).Name;
}
}
var exportDefinition = ClrMdHelper.GetObjectAs <ulong>(heap, export, FIELD_Definition);
string contract = ClrMdHelper.GetObjectAs <string>(heap, exportDefinition, FIELD_ContractName);
var metadata = ClrMdHelper.GetLastObjectInHierarchyAsKVPs(heap, exportDefinition, HIERARCHY_ExportDefinition_To_Metadata, 0, TYPE_KVP_String_Object);
string typeId = "";
foreach (var entry in metadata)
{
if (ClrMdHelper.GetStringContents(heap, entry.key) == CONST_ExportTypeIdentity)
{
typeId = ClrMdHelper.GetStringContents(heap, entry.value);
break;
}
}
var rcp = new ReflectionComposablePart();
rcp.TypeName = exportedValueTypeName ?? typeId;
rcp.IsCreated = true;
rcp.Exports.Add(new ExportDefinition()
{
ContractName = contract, TypeIdentity = typeId
});
MergeResults(RESULT, rcp);
}
else
{
Console.WriteLine($"WARNING: Unsupported ComposablePart was found: {composablePartTypeName}");
}
}
}
// Check if there exists a CatalogExportProvider
ulong catalogExProvider = ClrMdHelper.GetObjectAs <ulong>(heap, obj, FIELD_CatalogExportProvider);
if (catalogExProvider != 0)
{
ulong catalogFieldValue = ClrMdHelper.GetObjectAs <ulong>(heap, catalogExProvider, FIELD_Catalog);
HashSet <ulong> parts = new HashSet <ulong>();
InvokeCatalogHandler(heap, catalogFieldValue, parts);
foreach (var part in parts)
{
var rcp = ProcessReflectionComposablePartDefinition(heap, part);
MergeResults(RESULT, rcp);
}
Console.WriteLine($"{RESULT.Count} parts were found: ");
foreach (var part in RESULT.Keys)
{
Console.WriteLine($"\t{part}");
}
Console.WriteLine();
// Get activated auto-created parts
var activePartObjs = ClrMdHelper.GetLastObjectInHierarchyAsKVPs(heap, catalogExProvider, HIERARCHY_CatalogExportProvider_To_Activated, 0, TYPE_ComposablePartDefinitionArray2);
var activatedPartNames = new HashSet <string>();
foreach (var activePart in activePartObjs)
{
ulong partCreationInfo = ClrMdHelper.GetObjectAs <ulong>(heap, activePart.key, FIELD_CreationInfo);
string partType = InvokePartCreationInfoHandler(heap, partCreationInfo);
activatedPartNames.Add(partType);
}
foreach (var rcp in RESULT)
{
if (activatedPartNames.Contains(rcp.Key))
{
rcp.Value.IsCreated = true;
}
}
DgmlHelper.CreateDgml($"{obj:X}.dgml", RESULT.Select(x => x.Value));
}
else
{
Console.WriteLine("INFO: No CatalogExportProvider was found.");
}
}
static void Main(string[] args)
{
var retCode = ArgParser.Parse(args, new string[] { "-h", "-?", "/?" }, new string[] { "-a", "-d", "-pid" });
ValidateArguments(retCode);
string switchArg = ArgParser.Switches.FirstOrDefault();
if (switchArg != null)
{
switch (switchArg)
{
case "-h":
case "-?":
case "/?":
{
PrintSyntaxAndExit(retCode);
break;
}
}
}
var kvp = ArgParser.SwitchesWithValues.FirstOrDefault();
if (!kvp.Equals(default(KeyValuePair <string, string>)))
{
switch (kvp.Key)
{
case "-a":
{
var assemblies = kvp.Value.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var assembly in assemblies)
{
ValidateFile(assembly);
}
var aggrCat = new AggregateCatalog(assemblies.Select(x => new AssemblyCatalog(x)));
var RESULT = new List <ReflectionComposablePart>();
using (var container = new CompositionContainer(aggrCat))
{
foreach (var part in container.Catalog.Parts)
{
var rfc = new ReflectionComposablePart();
rfc.TypeName = part.ToString();
foreach (var import in part.ImportDefinitions)
{
var impDef = new ImportDefinition();
string[] s = ParseImportDefinition(import.ToString());
impDef.ContractName = s[0].Substring(s[0].IndexOf("\t") + 1);
impDef.RequiredTypeIdentity = s[1].Substring(s[1].IndexOf("\t") + 1);
rfc.Imports.Add(impDef);
}
foreach (var export in part.ExportDefinitions)
{
var expDef = new ExportDefinition();
expDef.ContractName = export.ContractName;
expDef.TypeIdentity = (string)export.Metadata[CONST_ExportTypeIdentity];
rfc.Exports.Add(expDef);
}
RESULT.Add(rfc);
}
}
DgmlHelper.CreateDgml($"{Guid.NewGuid().ToString()}.dgml", RESULT);
break;
}
case "-d":
{
string dumpFile = kvp.Value;
ValidateFile(dumpFile);
var wrapper = ClrMdHelper.LoadDumpFile(dumpFile);
InitAndStartProcessing(wrapper);
break;
}
case "-pid":
{
if (int.TryParse(kvp.Value, out int pid))
{
var wrapper = ClrMdHelper.AttachToLiveProcess(pid);
InitAndStartProcessing(wrapper);
}
else
{
Console.WriteLine($"ERROR: Invalid process id.");
Environment.Exit(1);
}
break;
}
}
}
}
