public IAssemblyDecompilationResults GenerateFiles(CancellationToken cancellationToken)
{
this.decompilationResults = new Dictionary <uint, Dictionary <uint, IDecompilationResults> >();
BuildProjectCancellable(cancellationToken);
ICollection <IModuleDecompilationResults> moduleDecompilationResults = new List <IModuleDecompilationResults>();
foreach (KeyValuePair <uint, Dictionary <uint, IDecompilationResults> > pair in this.decompilationResults)
{
uint moduleToken = pair.Key;
moduleDecompilationResults.Add(new ModuleDecompilationResults(moduleToken, GetModuleFilePathByToken(moduleToken), pair.Value));
}
string assemblyAttributesFilePath = GetAssemblyAttributesFilePath();
IDecompilationResults assemblyAttributesDecompilationResults = GetAssemblyAttributesDecompilationResults(assemblyAttributesFilePath);
ProjectGenerationDecompilationCacheService.ClearAssemblyContextsCache();
this.currentAssemblyResolver.ClearCache();
this.currentAssemblyResolver.ClearAssemblyFailedResolverCache();
ICollection <string> resourcesFilePaths = new List <string>();
foreach (string resourceFilePath in this.resourcesToPathsMap.Values)
{
resourcesFilePaths.Add(Path.Combine(this.targetDir, resourceFilePath));
}
foreach (string xamlResourceFilePath in this.xamlResourcesToPathsMap.Values)
{
resourcesFilePaths.Add(Path.Combine(this.targetDir, xamlResourceFilePath));
}
return(new AssemblyDecompilationResults(this.assemblyPath, assemblyAttributesDecompilationResults, moduleDecompilationResults, resourcesFilePaths));
}
public DecompiledSourceCode(MemberDefinitionMetadataBase memberNode, IDecompilationResults decompilationResult, string sourceCode)
: this(sourceCode)
{
this.memberMetadata = memberNode;
this.decompilationResult = decompilationResult;
}
public AssemblyDecompilationResults(string assemblyFilePath, IDecompilationResults assemblyAttributesDecompilationResults, ICollection <IModuleDecompilationResults> moduleDecompilationResults,
ICollection <string> resourcesFilepaths)
{
this.AssemblyFilePath = assemblyFilePath;
this.AssemblyAttributesDecompilationResults = assemblyAttributesDecompilationResults;
this.ModuleDecompilationResults = moduleDecompilationResults;
this.ResourcesFilePaths = resourcesFilepaths;
}
protected MemberNodeBase(
NamespaceNode parent,
IOldToNewTupleMap <MemberDefinitionMetadataBase> map,
IDecompilationResults oldDecompileResult,
IDecompilationResults newDecompileResult)
: base(parent, parent.Namespace, map.GetFirstNotNullItem().GetName())
{
Map = map;
OldDecompileResult = oldDecompileResult;
NewDecompileResult = newDecompileResult;
}
private void GetAttributeDecompilationResult(string filePath, ref IDecompilationResults decompilationResults)
{
if (decompilationResults == null)
{
IAssemblyDecompilationResults assemblyResult = GetAssemblyResult(filePath);
if (assemblyResult == null)
{
return;
}
decompilationResults = assemblyResult.AssemblyAttributesDecompilationResults;
}
}
public TypeNode(
NamespaceNode parent,
IOldToNewTupleMap <TypeMetadata> map,
IReadOnlyList <MemberNodeBase> members,
IDecompilationResults oldDecompileResult,
IDecompilationResults newDecompileResult)
: base(parent, map, oldDecompileResult, newDecompileResult)
{
Parent = parent;
Map = map;
Members = members;
}
public static TypeNode Create(NamespaceNode parent, IOldToNewTupleMap <TypeMetadata> map)
{
var oldTypeMetadata = map.OldType;
var newTypeMetadata = map.NewType;
IDecompilationResults oldResult = null;
IDecompilationResults newResult = null;
IDecompilationResults result;
if (oldTypeMetadata != null &&
GlobalDecompilationResultsRepository.Instance.TryGetDecompilationResult(
oldTypeMetadata.AssemblyPath,
oldTypeMetadata.Module.TokenId,
oldTypeMetadata.TokenId,
out result))
{
oldResult = result;
}
if (newTypeMetadata != null &&
GlobalDecompilationResultsRepository.Instance.TryGetDecompilationResult(
newTypeMetadata.AssemblyPath,
newTypeMetadata.Module.TokenId,
newTypeMetadata.TokenId,
out result))
{
newResult = result;
}
var typeNode = new TypeNode(parent, map, new MemberNodeBase[0], oldResult, newResult);
var memberManager = new MemberMergeManager(map);
var members = memberManager.GetMergedCollection().Select <IOldToNewTupleMap <MemberDefinitionMetadataBase>, MemberNodeBase> (
e =>
{
if (e.GetFirstNotNullItem().MemberType == MemberType.Type)
{
return(NestedTypeNode.Create(
typeNode,
new OldToNewTupleMap <TypeMetadata> ((TypeMetadata)e.OldType, (TypeMetadata)e.NewType)));
}
return(new MemberNode(
typeNode,
new OldToNewTupleMap <MemberMetadata> ((MemberMetadata)e.OldType, (MemberMetadata)e.NewType)));
}).ToArray();
typeNode.Members = members;
return(typeNode);
}
protected string GetFullSource(IDecompilationResults result)
{
if (result == null)
{
return(string.Empty);
}
try
{
return(File.ReadAllText(result.FilePath));
}
catch
{
return(string.Empty);
}
}
protected string GetMemberSource(IDecompilationResults result, MemberDefinitionMetadataBase metadata)
{
if (metadata == null || result == null)
{
return(string.Empty);
}
IOffsetSpan offsetSpan;
if (result.MemberTokenToDecompiledCodeMap.TryGetValue(metadata.TokenId, out offsetSpan))
{
try
{
string source = File.ReadAllText(result.FilePath);
return(GetMemberSource(source, offsetSpan, metadata.TokenId, result));
}
catch
{
return(string.Empty);
}
}
return(string.Empty);
}
private string CleanExceptionSource(IDecompilationResults decompilationResult, string sourceCode)
{
var spansForRemoving = new List <IOffsetSpan>();
foreach (uint memberId in decompilationResult.MembersWithExceptions)
{
IOffsetSpan memberOffset;
if (decompilationResult.MemberTokenToDecompiledCodeMap.TryGetValue(memberId, out memberOffset))
{
spansForRemoving.Add(memberOffset);
}
}
spansForRemoving.Sort((i1, i2) => i2.StartOffset.CompareTo(i1.StartOffset));
for (int i = 0; i < spansForRemoving.Count; i++)
{
IOffsetSpan memberOffset = spansForRemoving[i];
sourceCode = sourceCode.Remove(memberOffset.StartOffset, memberOffset.EndOffset - memberOffset.StartOffset + 1);
}
return(sourceCode);
}
private string GetMemberSource(string sourceCode, IOffsetSpan memberOffset, uint memberId, IDecompilationResults decompilationResult)
{
StringBuilder memberSourceBuilder = new StringBuilder();
memberSourceBuilder.Append(GetMemberSourceFromMap(sourceCode, decompilationResult.MemberTokenToAttributesMap, memberId))
.Append(GetMemberSourceFromMap(sourceCode, decompilationResult.MemberTokenToDocumentationMap, memberId))
.Append(sourceCode.Substring(memberOffset.StartOffset, memberOffset.EndOffset - memberOffset.StartOffset + 1));
return(memberSourceBuilder.ToString());
}
public bool TryGetDecompilationResult(string assemblyPath, uint moduleId, uint typeId, out IDecompilationResults target)
{
target = null;
IAssemblyDecompilationResults decompilationResult;
if (cache.TryGetValue(assemblyPath, out decompilationResult))
{
IModuleDecompilationResults moduleResult = decompilationResult.ModuleDecompilationResults.FirstOrDefault(m => m.ModuleToken == moduleId);
if (moduleResult != null)
{
bool succeeded = moduleResult.TypeDecompilationResults.TryGetValue(typeId, out target);
return(succeeded);
}
}
return(false);
}
