CSharpDecompiler CreateDecompiler(PEFile module, DecompilationOptions options)
{
CSharpDecompiler decompiler = new CSharpDecompiler(module, module.GetAssemblyResolver(), options.DecompilerSettings);
decompiler.CancellationToken = options.CancellationToken;
decompiler.DebugInfoProvider = module.GetDebugInfoOrNull();
while (decompiler.AstTransforms.Count > transformCount)
{
decompiler.AstTransforms.RemoveAt(decompiler.AstTransforms.Count - 1);
}
if (options.EscapeInvalidIdentifiers)
{
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
}
return(decompiler);
}
public override void Disassemble(PEFile module, MethodDefinitionHandle handle)
{
try {
var csharpOutput = new StringWriter();
CSharpDecompiler decompiler = CreateDecompiler(module, options);
var st = decompiler.Decompile(handle);
WriteCode(csharpOutput, options.DecompilerSettings, st, decompiler.TypeSystem);
var mapping = decompiler.CreateSequencePoints(st).FirstOrDefault(kvp => (kvp.Key.MoveNextMethod ?? kvp.Key.Method).MetadataToken == handle);
this.sequencePoints = mapping.Value ?? (IList <SequencePoint>)EmptyList <SequencePoint> .Instance;
this.codeLines = csharpOutput.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None);
base.Disassemble(module, handle);
} finally {
this.sequencePoints = null;
this.codeLines = null;
}
}
private void AddToProviderMap(CSharpDecompiler dc, string assemblyPath, IEntity entity)
{
if (!_tokenToProviderMap.ContainsKey(assemblyPath))
{
_tokenToProviderMap.Add(assemblyPath, new Dictionary <MetadataToken, IEntity>());
}
var token = entity is ITypeDefinition type
? dc.TypeSystem.GetCecil(type)?.MetadataToken
: dc.TypeSystem.GetCecil((IMember)entity)?.MetadataToken;
if (token.HasValue)
{
_tokenToProviderMap[assemblyPath][token.Value] = entity;
}
}
public static string ToSourceCode(this Type source)
{
if (source.IsNested)
{
throw new NotSupportedException("Decompilation of nested types is not supported");
}
if (!source.IsClass)
{
throw new NotSupportedException("Decompilation of non-reference types is not supported");
}
var decompiler = new CSharpDecompiler(source.Assembly.Location, new DecompilerSettings());
return(decompiler.DecompileTypeAsString(new FullTypeName(source.FullName)));
}
protected static void AssertRoundtripCode(string fileName, bool optimize = false, bool useDebug = false, int compilerVersion = 4)
{
var code = RemoveIgnorableLines(File.ReadLines(fileName));
AssemblyDefinition assembly = CompileLegacy(code, optimize, useDebug, compilerVersion);
CSharpDecompiler decompiler = new CSharpDecompiler(assembly.MainModule, new DecompilerSettings());
decompiler.AstTransforms.Insert(0, new RemoveCompilerAttribute());
var syntaxTree = decompiler.DecompileWholeModuleAsSingleFile();
var options = FormattingOptionsFactory.CreateAllman();
options.IndentSwitchBody = false;
CodeAssert.AreEqual(code, syntaxTree.ToString(options));
}
public override void DecompileMethod(IMethod method, ITextOutput output, DecompilationOptions options)
{
base.DecompileMethod(method, output, options);
var module = method.ParentModule.PEFile;
var metadata = module.Metadata;
var methodDef = metadata.GetMethodDefinition((SRM.MethodDefinitionHandle)method.MetadataToken);
if (!methodDef.HasBody())
{
return;
}
IAssemblyResolver assemblyResolver = module.GetAssemblyResolver();
var typeSystem = new DecompilerTypeSystem(module, assemblyResolver);
var reader = new ILReader(typeSystem.MainModule);
reader.UseDebugSymbols = options.DecompilerSettings.UseDebugSymbols;
var methodBody = module.Reader.GetMethodBody(methodDef.RelativeVirtualAddress);
ILFunction il = reader.ReadIL((SRM.MethodDefinitionHandle)method.MetadataToken, methodBody, kind: ILFunctionKind.TopLevelFunction, cancellationToken: options.CancellationToken);
var decompiler = new CSharpDecompiler(typeSystem, options.DecompilerSettings)
{
CancellationToken = options.CancellationToken
};
ILTransformContext context = decompiler.CreateILTransformContext(il);
context.Stepper.StepLimit = options.StepLimit;
context.Stepper.IsDebug = options.IsDebug;
try {
il.RunTransforms(transforms, context);
} catch (StepLimitReachedException) {
} catch (Exception ex) {
output.WriteLine(ex.ToString());
output.WriteLine();
output.WriteLine("ILAst after the crash:");
} finally {
// update stepper even if a transform crashed unexpectedly
if (options.StepLimit == int.MaxValue)
{
Stepper = context.Stepper;
OnStepperUpdated(new EventArgs());
}
}
(output as ISmartTextOutput)?.AddButton(Images.ViewCode, "Show Steps", delegate {
Docking.DockWorkspace.Instance.ShowToolPane(DebugStepsPaneModel.PaneContentId);
});
output.WriteLine();
il.WriteTo(output, DebugSteps.Options);
}
IEnumerable <Tuple <string, string> > WriteCodeFilesInProject(Metadata.PEFile module, CancellationToken cancellationToken)
{
var metadata = module.Metadata;
var files = module.Metadata.GetTopLevelTypeDefinitions().Where(td => IncludeTypeWhenDecompilingProject(module, td)).GroupBy(
delegate(TypeDefinitionHandle h) {
var type = metadata.GetTypeDefinition(h);
string file = CleanUpFileName(metadata.GetString(type.Name)) + ".cs";
if (string.IsNullOrEmpty(metadata.GetString(type.Namespace)))
{
return(file);
}
else
{
string dir = CleanUpFileName(metadata.GetString(type.Namespace));
if (directories.Add(dir))
{
Directory.CreateDirectory(Path.Combine(targetDirectory, dir));
}
return(Path.Combine(dir, file));
}
}, StringComparer.OrdinalIgnoreCase).ToList();
int total = files.Count;
var progress = this.ProgressIndicator;
DecompilerTypeSystem ts = new DecompilerTypeSystem(module, AssemblyResolver, settings);
Parallel.ForEach(
files,
new ParallelOptions {
MaxDegreeOfParallelism = this.MaxDegreeOfParallelism,
CancellationToken = cancellationToken
},
delegate(IGrouping <string, TypeDefinitionHandle> file) {
using (StreamWriter w = new StreamWriter(Path.Combine(targetDirectory, file.Key))) {
try {
CSharpDecompiler decompiler = CreateDecompiler(ts);
decompiler.CancellationToken = cancellationToken;
var syntaxTree = decompiler.DecompileTypes(file.ToArray());
syntaxTree.AcceptVisitor(new CSharpOutputVisitor(w, settings.CSharpFormattingOptions));
} catch (Exception innerException) when(!(innerException is OperationCanceledException || innerException is DecompilerException))
{
throw new DecompilerException(module, $"Error decompiling for '{file.Key}'", innerException);
}
}
progress?.Report(new DecompilationProgress(total, file.Key));
});
return(files.Select(f => Tuple.Create("Compile", f.Key)).Concat(WriteAssemblyInfo(ts, cancellationToken)));
}
public bool DllCompare(string srcPath, string dstPath, out List <string> errorList)
{
errorList = new List <string>();
string[] separators = { "\r\n" };
var module = ModuleDefinition.ReadModule(srcPath);
var typeFullNameList = (from type in module.Types where type.IsPublic select type.FullName).ToList();
var dllequal = true;
foreach (var typeFullName in typeFullNameList)
{
try
{
var name = new FullTypeName(typeFullName);
var decompiler1 = new CSharpDecompiler(srcPath, new ICSharpCode.Decompiler.DecompilerSettings());
var x1 = decompiler1.DecompileTypeAsString(name);
var lines1 = x1.Split(separators, StringSplitOptions.None);
var decompiler2 = new CSharpDecompiler(dstPath, new ICSharpCode.Decompiler.DecompilerSettings());
var x2 = decompiler2.DecompileTypeAsString(name);
var lines2 = x2.Split(separators, StringSplitOptions.None);
if (lines1.Length != lines2.Length)
{
dllequal = false;
errorList.Add("\t" + srcPath + "\t" + typeFullName + "\t" + "(decompilable)");
continue;
}
if (!lines1.Where((t, i) => t != lines2[i]).Any())
{
continue;
}
dllequal = false;
errorList.Add("\t" + srcPath + "\t" + typeFullName + "\t" + "(decompilable)");
}
catch (Exception ex)
{
errorList.Add("\t\t" + ex.Message);
return(false);
}
}
return(dllequal);
}
public DocumentationGenerator(string assemblyFilePath, string documentationFilePath, string homePageName, string linksFiles)
{
_decompiler = new CSharpDecompiler(assemblyFilePath, new DecompilerSettings());
_documentationProvider = new XmlDocumentationProvider(documentationFilePath);
_docItems = new Dictionary <string, DocItem>();
foreach (DocItem item in GetDocItems(homePageName))
{
_docItems.Add(item.Id, item);
}
_links = new Dictionary <string, string>();
foreach ((string id, string link) in GetExternalLinks(linksFiles))
{
_links[id] = link;
}
}
protected override void ProcessRecord()
{
string path = GetUnresolvedProviderPathFromPSPath(LiteralPath);
try {
var decompiler = new CSharpDecompiler(path, new DecompilerSettings(LanguageVersion)
{
ThrowOnAssemblyResolveErrors = false,
RemoveDeadCode = RemoveDeadCode,
RemoveDeadStores = RemoveDeadStores
});
WriteObject(decompiler);
} catch (Exception e) {
WriteVerbose(e.ToString());
WriteError(new ErrorRecord(e, ErrorIds.AssemblyLoadFailed, ErrorCategory.OperationStopped, null));
}
}
private static string getMethod(string id, CSharpDecompiler decompiler)
{
string[] split = id.Split("|");
string type = split[0];
string method = split[1];
string[] param = split[2].Split(",");
try
{
return(decompiler.DecompileAsString(decompiler.TypeSystem.MainModule.Compilation.FindType(new FullTypeName(type)).GetDefinition().Methods.Where(x => x.Name.Equals(method) && (!x.Parameters.Any() || (x.Parameters.ToList().Select(y => y.Type.ReflectionName).SequenceEqual(param)))).First().MetadataToken));
}
catch (InvalidOperationException)
{
return("-1");
}
}
internal static void GeneratePdbForAssembly(LoadedAssembly assembly)
{
var file = assembly.GetPEFileOrNull();
if (!PortablePdbWriter.HasCodeViewDebugDirectoryEntry(file))
{
MessageBox.Show(string.Format(Resources.CannotCreatePDBFile, Path.GetFileName(assembly.FileName)));
return;
}
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = DecompilerTextView.CleanUpName(assembly.ShortName) + ".pdb";
dlg.Filter = Resources.PortablePDBPdbAllFiles;
dlg.InitialDirectory = Path.GetDirectoryName(assembly.FileName);
if (dlg.ShowDialog() != true)
{
return;
}
DecompilationOptions options = new DecompilationOptions();
string fileName = dlg.FileName;
Docking.DockWorkspace.Instance.RunWithCancellation(ct => Task <AvalonEditTextOutput> .Factory.StartNew(() => {
AvalonEditTextOutput output = new AvalonEditTextOutput();
Stopwatch stopwatch = Stopwatch.StartNew();
using (FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write))
{
try
{
var decompiler = new CSharpDecompiler(file, assembly.GetAssemblyResolver(), options.DecompilerSettings);
PortablePdbWriter.WritePdb(file, decompiler, options.DecompilerSettings, stream);
}
catch (OperationCanceledException)
{
output.WriteLine();
output.WriteLine(Resources.GenerationWasCancelled);
throw;
}
}
stopwatch.Stop();
output.WriteLine(Resources.GenerationCompleteInSeconds, stopwatch.Elapsed.TotalSeconds.ToString("F1"));
output.WriteLine();
output.AddButton(null, Resources.OpenExplorer, delegate { Process.Start("explorer", "/select,\"" + fileName + "\""); });
output.WriteLine();
return(output);
}, ct)).Then(output => Docking.DockWorkspace.Instance.ShowText(output)).HandleExceptions();
}
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
AddReferenceWarningMessage(method.Module.Assembly, output);
WriteCommentLine(output, TypeToString(method.DeclaringType, includeNamespace: true));
CSharpDecompiler decompiler = CreateDecompiler(method.Module, options);
if (method.IsConstructor && !method.DeclaringType.IsValueType)
{
List <IMemberDefinition> members = CollectFieldsAndCtors(method.DeclaringType, method.IsStatic);
decompiler.AstTransforms.Add(new SelectCtorTransform(decompiler.TypeSystem.Resolve(method)));
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(members), decompiler.TypeSystem);
}
else
{
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(method), decompiler.TypeSystem);
}
}
public override void DecompileField(FieldDefinition field, ITextOutput output, DecompilationOptions options)
{
AddReferenceWarningMessage(field.Module.Assembly, output);
WriteCommentLine(output, TypeToString(field.DeclaringType, includeNamespace: true));
CSharpDecompiler decompiler = CreateDecompiler(field.Module, options);
if (field.IsLiteral)
{
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(field), decompiler.TypeSystem);
}
else
{
List <IMemberDefinition> members = CollectFieldsAndCtors(field.DeclaringType, field.IsStatic);
decompiler.AstTransforms.Add(new SelectFieldTransform(decompiler.TypeSystem.Resolve(field)));
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(members), decompiler.TypeSystem);
}
}
public static string[] compareRich(string[] ids, string decompiler1t, string decompiler2t)
{
CSharpDecompiler decompiler1 = new CSharpDecompiler(decompiler1t, new DecompilerSettings());
CSharpDecompiler decompiler2 = new CSharpDecompiler(decompiler2t, new DecompilerSettings());
List <string> list = new List <string>();
for (int i = 0; i < ids.Length; i++)
{
if (!compare(ids[i], decompiler1, decompiler2))
{
string[] split = ids[0].Split("|");
list.Add(split[0] + "." + split[1] + "(" + String.Join(", ", split[2].Split(",")) + ")");
}
}
return(list.ToArray());
}
public static Boolean compare(string id, CSharpDecompiler decompiler1, CSharpDecompiler decompiler2)
{
try
{
string method1 = getMethod(id, decompiler2);
string method2 = getMethod(id, decompiler1);
if (method1 == "-1" || method2 == "-1")
{
return(false);
}
return(method1.Equals(method2));
}
catch (Exception)
{
return(false);
}
}
public static CSharpDecompiler GetDecompilerForSnippet(string csharpText)
{
var syntaxTree = SyntaxFactory.ParseSyntaxTree(csharpText);
var compilation = CSharpCompilation.Create(
"TestAssembly",
new[] { syntaxTree },
defaultReferences.Value,
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var peStream = new MemoryStream();
var emitResult = compilation.Emit(peStream);
peStream.Position = 0;
var moduleDefinition = ModuleDefinition.ReadModule(peStream);
var decompiler = new CSharpDecompiler(moduleDefinition, new DecompilerSettings());
return(decompiler);
}
public bool AddAssembly(string path)
{
try
{
var decompiler = new CSharpDecompiler(path, new DecompilerSettings()
{
ThrowOnAssemblyResolveErrors = false
});
_decompilers[path] = decompiler;
return(true);
}
catch (Exception ex)
{
_logger?.LogError("An exception occurred when reading assembly {assembly}: {exception}", path, ex);
}
return(false);
}
/// <summary>
/// Instianciates a CSharpDecompiler from a given assemblyfilename and applies decompilersettings
/// </summary>
/// <param name="assemblyFileName">path for assemblyfile to decompile</param>
/// <param name="settings">optional decompiler settings</param>
/// <returns>Instance of CSharpDecompiler</returns>
public CSharpDecompiler GetCSharpDecompiler(string assemblyFileName, DecompilerSettings settings = null)
{
if (settings == null)
{
settings = new DecompilerSettings();
}
using (var file = new FileStream(assemblyFileName, FileMode.Open, FileAccess.Read))
{
var module = new PEFile(assemblyFileName, file, PEStreamOptions.PrefetchEntireImage);
var resolver = new UniversalAssemblyResolver(assemblyFileName, false,
module.Reader.DetectTargetFrameworkId(), PEStreamOptions.PrefetchMetadata);
resolver.AddSearchDirectory(Path.GetDirectoryName(module.FullName));
var typeSystem = new DecompilerTypeSystem(module, resolver, settings);
var decompiler = new CSharpDecompiler(typeSystem, settings);
decompiler.DebugInfoProvider = DebugInfoLoader.LoadSymbols(module);
return(decompiler);
}
}
public override void Disassemble(MethodBody body)
{
var method = body.Method;
try {
var csharpOutput = new StringWriter();
CSharpDecompiler decompiler = CreateDecompiler(method.Module, options);
var st = decompiler.Decompile(method);
WriteCode(csharpOutput, options.DecompilerSettings, st, decompiler.TypeSystem);
var mapping = decompiler.CreateSequencePoints(st).FirstOrDefault(kvp => kvp.Key.CecilMethod == method);
this.sequencePoints = mapping.Value ?? (IList <IL.SequencePoint>)EmptyList <IL.SequencePoint> .Instance;
this.codeLines = csharpOutput.ToString().Split(new[] { Environment.NewLine }, StringSplitOptions.None);
base.Disassemble(body);
} finally {
this.sequencePoints = null;
this.codeLines = null;
}
}
private void TestGeneratePdb([CallerMemberName] string testName = null)
{
const PdbToXmlOptions options = PdbToXmlOptions.IncludeEmbeddedSources | PdbToXmlOptions.ThrowOnError | PdbToXmlOptions.IncludeTokens | PdbToXmlOptions.ResolveTokens | PdbToXmlOptions.IncludeMethodSpans;
string xmlFile = Path.Combine(TestCasePath, testName + ".xml");
string xmlContent = File.ReadAllText(xmlFile);
XDocument document = XDocument.Parse(xmlContent);
var files = document.Descendants("file").ToDictionary(f => f.Attribute("name").Value, f => f.Value);
Tester.CompileCSharpWithPdb(Path.Combine(TestCasePath, testName + ".expected"), files);
string peFileName = Path.Combine(TestCasePath, testName + ".expected.dll");
string pdbFileName = Path.Combine(TestCasePath, testName + ".expected.pdb");
var moduleDefinition = new PEFile(peFileName);
var resolver = new UniversalAssemblyResolver(peFileName, false, moduleDefinition.Reader.DetectTargetFrameworkId(), PEStreamOptions.PrefetchEntireImage);
var decompiler = new CSharpDecompiler(moduleDefinition, resolver, new DecompilerSettings());
using (FileStream pdbStream = File.Open(Path.Combine(TestCasePath, testName + ".pdb"), FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
pdbStream.SetLength(0);
PortablePdbWriter.WritePdb(moduleDefinition, decompiler, new DecompilerSettings(), pdbStream, noLogo: true);
pdbStream.Position = 0;
using (Stream peStream = File.OpenRead(peFileName))
using (Stream expectedPdbStream = File.OpenRead(pdbFileName))
{
using (StreamWriter writer = new StreamWriter(Path.ChangeExtension(pdbFileName, ".xml"), false, Encoding.UTF8))
{
PdbToXmlConverter.ToXml(writer, expectedPdbStream, peStream, options);
}
peStream.Position = 0;
using (StreamWriter writer = new StreamWriter(Path.ChangeExtension(xmlFile, ".generated.xml"), false, Encoding.UTF8))
{
PdbToXmlConverter.ToXml(writer, pdbStream, peStream, options);
}
}
}
string expectedFileName = Path.ChangeExtension(xmlFile, ".expected.xml");
ProcessXmlFile(expectedFileName);
string generatedFileName = Path.ChangeExtension(xmlFile, ".generated.xml");
ProcessXmlFile(generatedFileName);
Assert.AreEqual(Normalize(expectedFileName), Normalize(generatedFileName));
}
public static string DecompileCSharp(string assemblyFileName)
{
using (var module = ModuleDefinition.ReadModule(assemblyFileName)) {
var typeSystem = new DecompilerTypeSystem(module);
CSharpDecompiler decompiler = new CSharpDecompiler(typeSystem, new DecompilerSettings());
decompiler.AstTransforms.Insert(0, new RemoveCompilerAttribute());
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
var syntaxTree = decompiler.DecompileWholeModuleAsSingleFile();
StringWriter output = new StringWriter();
var visitor = new CSharpOutputVisitor(output, FormattingOptionsFactory.CreateSharpDevelop());
syntaxTree.AcceptVisitor(visitor);
string fileName = Path.GetTempFileName();
File.WriteAllText(fileName, output.ToString());
return(fileName);
}
}
public override void DecompileMethod(MethodDefinition method, ITextOutput output, DecompilationOptions options)
{
base.DecompileMethod(method, output, options);
if (!method.HasBody)
{
return;
}
var typeSystem = new DecompilerTypeSystem(method.Module);
var specializingTypeSystem = typeSystem.GetSpecializingTypeSystem(new SimpleTypeResolveContext(typeSystem.Resolve(method)));
var reader = new ILReader(specializingTypeSystem);
reader.UseDebugSymbols = options.DecompilerSettings.UseDebugSymbols;
ILFunction il = reader.ReadIL(method.Body, options.CancellationToken);
var namespaces = new HashSet <string>();
var decompiler = new CSharpDecompiler(typeSystem, options.DecompilerSettings)
{
CancellationToken = options.CancellationToken
};
ILTransformContext context = decompiler.CreateILTransformContext(il);
context.Stepper.StepLimit = options.StepLimit;
context.Stepper.IsDebug = options.IsDebug;
try {
il.RunTransforms(transforms, context);
} catch (StepLimitReachedException) {
} catch (Exception ex) {
output.WriteLine(ex.ToString());
output.WriteLine();
output.WriteLine("ILAst after the crash:");
} finally {
// update stepper even if a transform crashed unexpectedly
if (options.StepLimit == int.MaxValue)
{
Stepper = context.Stepper;
OnStepperUpdated(new EventArgs());
}
}
(output as ISmartTextOutput)?.AddButton(Images.ViewCode, "Show Steps", delegate {
DebugSteps.Show();
});
output.WriteLine();
il.WriteTo(output, DebugSteps.Options);
}
private void PopulateTokenToProviderMap(CSharpDecompiler dc, string assemblyPath, ITypeDefinition typeDefinition)
{
if (typeDefinition == null)
{
return;
}
AddToProviderMap(dc, assemblyPath, typeDefinition);
foreach (var member in typeDefinition.Members)
{
AddToProviderMap(dc, assemblyPath, member);
}
foreach (var nestedType in typeDefinition.NestedTypes)
{
PopulateTokenToProviderMap(dc, assemblyPath, nestedType);
}
}
public static CSharpDecompiler GetDecompilerForSnippet(string csharpText)
{
var syntaxTree = SyntaxFactory.ParseSyntaxTree(csharpText);
var compilation = CSharpCompilation.Create(
"TestAssembly",
new[] { syntaxTree },
defaultReferences.Value,
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var peStream = new MemoryStream();
var emitResult = compilation.Emit(peStream);
peStream.Position = 0;
var moduleDefinition = new PEFile("TestAssembly.dll", peStream, PEStreamOptions.PrefetchEntireImage);
var resolver = new UniversalAssemblyResolver("TestAssembly.dll", false, moduleDefinition.Reader.DetectTargetFrameworkId(), PEStreamOptions.PrefetchEntireImage);
var decompiler = new CSharpDecompiler(moduleDefinition, resolver, new DecompilerSettings());
return(decompiler);
}
private Document PerformDecompilation(Document document, string fullName, Compilation compilation, string assemblyLocation)
{
// Load the assembly.
var file = new PEFile(assemblyLocation, PEStreamOptions.PrefetchEntireImage);
// Initialize a decompiler with default settings.
var decompiler = new CSharpDecompiler(file, new AssemblyResolver(compilation), new DecompilerSettings());
// Escape invalid identifiers to prevent Roslyn from failing to parse the generated code.
// (This happens for example, when there is compiler-generated code that is not yet recognized/transformed by the decompiler.)
decompiler.AstTransforms.Add(new EscapeInvalidIdentifiers());
var fullTypeName = new FullTypeName(fullName);
// Try to decompile; if an exception is thrown the caller will handle it
var text = decompiler.DecompileTypeAsString(fullTypeName);
return(document.WithText(SourceText.From(text)));
}
internal static void GeneratePdbForAssembly(LoadedAssembly assembly)
{
var file = assembly.GetPEFileOrNull();
if (!PortablePdbWriter.HasCodeViewDebugDirectoryEntry(file))
{
MessageBox.Show($"Cannot create PDB file for {Path.GetFileName(assembly.FileName)}, because it does not contain a PE Debug Directory Entry of type 'CodeView'.");
return;
}
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = DecompilerTextView.CleanUpName(assembly.ShortName) + ".pdb";
dlg.Filter = "Portable PDB|*.pdb|All files|*.*";
dlg.InitialDirectory = Path.GetDirectoryName(assembly.FileName);
if (dlg.ShowDialog() != true)
{
return;
}
DecompilationOptions options = new DecompilationOptions();
string fileName = dlg.FileName;
MainWindow.Instance.TextView.RunWithCancellation(ct => Task <AvalonEditTextOutput> .Factory.StartNew(() => {
AvalonEditTextOutput output = new AvalonEditTextOutput();
Stopwatch stopwatch = Stopwatch.StartNew();
using (FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write)) {
try {
var decompiler = new CSharpDecompiler(file, assembly.GetAssemblyResolver(), options.DecompilerSettings);
PortablePdbWriter.WritePdb(file, decompiler, options.DecompilerSettings, stream);
} catch (OperationCanceledException) {
output.WriteLine();
output.WriteLine("Generation was cancelled.");
throw;
}
}
stopwatch.Stop();
output.WriteLine("Generation complete in " + stopwatch.Elapsed.TotalSeconds.ToString("F1") + " seconds.");
output.WriteLine();
output.AddButton(null, "Open Explorer", delegate { Process.Start("explorer", "/select,\"" + fileName + "\""); });
output.WriteLine();
return(output);
}, ct)).Then(output => MainWindow.Instance.TextView.ShowText(output)).HandleExceptions();
}
public override void DecompileField(IField field, ITextOutput output, DecompilationOptions options)
{
PEFile assembly = field.ParentModule.PEFile;
CSharpDecompiler decompiler = CreateDecompiler(assembly, options);
AddReferenceAssemblyWarningMessage(assembly, output);
AddReferenceWarningMessage(assembly, output);
WriteCommentLine(output, TypeToString(field.DeclaringType, includeNamespace: true));
if (field.IsConst)
{
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(field.MetadataToken), decompiler.TypeSystem);
}
else
{
var members = CollectFieldsAndCtors(field.DeclaringTypeDefinition, field.IsStatic);
var resolvedField = decompiler.TypeSystem.MainModule.GetDefinition((FieldDefinitionHandle)field.MetadataToken);
decompiler.AstTransforms.Add(new SelectFieldTransform(resolvedField));
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(members), decompiler.TypeSystem);
}
}
public override void DecompileMethod(IMethod method, ITextOutput output, DecompilationOptions options)
{
PEFile assembly = method.ParentModule.PEFile;
AddReferenceWarningMessage(assembly, output);
WriteCommentLine(output, TypeToString(method.DeclaringType, includeNamespace: true));
CSharpDecompiler decompiler = CreateDecompiler(assembly, options);
var methodDefinition = decompiler.TypeSystem.MainModule.ResolveEntity(method.MetadataToken) as IMethod;
if (methodDefinition.IsConstructor && methodDefinition.DeclaringType.IsReferenceType != false)
{
var members = CollectFieldsAndCtors(methodDefinition.DeclaringTypeDefinition, methodDefinition.IsStatic);
decompiler.AstTransforms.Add(new SelectCtorTransform(methodDefinition));
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(members), decompiler.TypeSystem);
}
else
{
WriteCode(output, options.DecompilerSettings, decompiler.Decompile(method.MetadataToken), decompiler.TypeSystem);
}
}
public Task HandleAsync(WorkspaceFile file, HandleFileOptions options, CancellationToken cancellationToken)
{
try
{
var decompiler = new CSharpDecompiler(
file.Path,
new DecompilerSettings());
file.Content = decompiler.DecompileWholeModuleAsString();
file.Meta.Language = "csharp";
}
catch (Exception ex)
{
Log.Warning(ex, "Could not decompile: {File}", file.Path);
}
return(Task.CompletedTask);
}
