public FileNode(AssemblyStream source, string resourcePath)
: base(null)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrWhiteSpace(resourcePath))
{
throw new ArgumentNullException("resourcePath");
}
_source = source;
_resourcePath = resourcePath;
_fileName = Path.GetFileName(_resourcePath);
_extension = Path.GetExtension(_fileName);
if (!string.IsNullOrEmpty(_extension))
{
_extension = _extension.ToLowerInvariant();
}
Header = CreateHeaderCore(DefaultImages.AssemblyBrowser.GetFileIcon(_fileName), null, resourcePath, true);
DefaultStyleKey = typeof(FileNode);
CompositionInitializer.SatisfyImports(this);
}
/// <summary>
/// Disposes of the object
/// </summary>
/// <param name="Managed">Destroy managed</param>
protected override void Dispose(bool Managed)
{
Save();
if (AssemblyStream != null)
{
AssemblyStream.Dispose();
AssemblyStream = null;
}
Classes = new List <Type>();
}
public ResourceNode(AssemblyDefinition declaringAssembly, AssemblyStream assemblySource, Resource resource)
: base(resource)
{
DefaultStyleKey = typeof(ResourceNode);
_declaringAssembly = declaringAssembly;
_assemblySource = assemblySource;
Header = CreateHeaderCore(DefaultImages.AssemblyBrowser.FileResource, null, resource.Name, true);
DataProvider = DoLoadType;
}
public AssemblyNode(AssemblyDefinition component, AssemblyStream source)
: base(component)
{
DefaultStyleKey = typeof(AssemblyNode);
_assemblySource = source;
var name = string.Format("{0} ({1})", component.Name.Name, component.IsSilverlight() ? "SL" : ".NET");
Header = CreateHeaderCore(DefaultImages.AssemblyBrowser.Assembly, null, name, true);
InitializeNode();
}
private void LoadAssembly(AssemblyDefinition definition, AssemblyStream source)
{
var node = new AssemblyNode(definition, source);
if (definition.IsSilverlight())
{
SilverlightAssemblies.Items.Add(node);
}
else
{
NetAssemblies.Items.Add(node);
}
}
/// <summary>
/// Saves the assembly
/// </summary>
protected void Save()
{
if ((AssemblyStream != null &&
!string.IsNullOrEmpty(AssemblyDirectory) &&
(!new FileInfo(AssemblyDirectory + "\\" + AssemblyName + ".dll").Exists ||
RegenerateAssembly)) &&
AssemblyStream.Length > 0)
{
using (FileStream TempStream = new FileInfo(AssemblyDirectory + "\\" + AssemblyName + ".dll").OpenWrite())
{
byte[] TempArray = AssemblyStream.ToArray();
TempStream.Write(TempArray, 0, TempArray.Length);
}
}
}
private static TreeNode GenerateNode(AssemblyStream entry, string header)
{
var ext = Path.GetExtension(header);
if (!string.IsNullOrWhiteSpace(ext))
{
ext = ext.ToLowerInvariant();
}
if (ext == ".dll")
{
var definition = AssemblyDefinition.ReadAssembly(entry.OpenRead());
return(new AssemblyNode(definition, entry));
}
return(new FileNode(entry, header));
}
/// <summary>
/// Adds the specified code.
/// </summary>
/// <param name="Code">The code.</param>
/// <param name="Usings">The usings.</param>
/// <param name="References">The references.</param>
/// <returns>The list of types that have been added</returns>
/// <exception cref="System.Exception">Any errors that are sent back by Roslyn</exception>
protected IEnumerable <Type> Add(string Code, IEnumerable <string> Usings, params Assembly[] References)
{
if (AssemblyStream == null)
{
return(null);
}
CSharpCompilation CSharpCompiler = CSharpCompilation.Create(AssemblyName + ".dll",
new SyntaxTree[] { CSharpSyntaxTree.ParseText(Code) },
References.ForEach(x => MetadataReference.CreateFromFile(x.Location)),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, usings: Usings, optimizationLevel: Optimize ? OptimizationLevel.Release : OptimizationLevel.Debug));
using (MemoryStream TempStream = new MemoryStream())
{
EmitResult Result = CSharpCompiler.Emit(TempStream);
if (!Result.Success)
{
throw new Exception(Code + System.Environment.NewLine + System.Environment.NewLine + Result.Diagnostics.ToString(x => x.GetMessage() + " : " + x.Location.GetLineSpan().StartLinePosition.Line, System.Environment.NewLine));
}
byte[] MiniAssembly = TempStream.ToArray();
Classes.AddIfUnique((x, y) => x.FullName == y.FullName, AppDomain.CurrentDomain.Load(MiniAssembly).GetTypes());
AssemblyStream.Write(MiniAssembly, 0, MiniAssembly.Length);
}
return(Classes);
}
public void Dispose()
{
AssemblyStream.Dispose();
SymbolStream?.Dispose();
}
private void LoadOrReplaceAssembly(AssemblyDefinition definition, AssemblyStream source)
{
var assemblyView = new AssemblyNode(definition, source);
AddOrReplaceAssemblyView(definition.IsSilverlight() ? SilverlightAssemblies : NetAssemblies, assemblyView);
}
public async Task <PackageEntry> Index(string id, string version)
{
var dependencies = new Dictionary <string, PackageArchiveReader>();
var frameworkEntries = new List <FrameworkEntry>();
try
{
using (var root = await _store.GetPackageAsync(id, version))
{
var targetNames = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var item in GetReferenceItems(root))
{
targetNames.Add(item.TargetFramework.GetShortFolderName());
}
var targets = targetNames.Select(NuGetFramework.Parse).ToArray();
if (!targets.Any())
{
return(null);
}
foreach (var target in targets)
{
var referenceGroup = GetReferenceItems(root, target);
Debug.Assert(referenceGroup != null);
await GetDependenciesAsync(dependencies, root, target);
// Add references
var referenceMetadata = new List <MetadataReference>();
foreach (var path in referenceGroup.Items)
{
var metadata = await AssemblyStream.CreateAsync(root.GetStream(path), path);
referenceMetadata.Add(metadata);
}
// Add dependencies
var dependencyMetadata = new List <MetadataReference>();
foreach (var dependency in dependencies.Values)
{
var dependencyReferences = GetReferenceItems(dependency, target);
if (dependencyReferences != null)
{
foreach (var path in dependencyReferences.Items)
{
var metadata = await AssemblyStream.CreateAsync(dependency.GetStream(path), path);
dependencyMetadata.Add(metadata);
}
}
}
// Add framework
var platformPaths = GetPlatformSet(target);
if (platformPaths == null)
{
if (!IsKnownUnsupportedPlatform(target))
{
Console.WriteLine($"error: can't resolve platform references for {target}");
}
continue;
}
foreach (var path in platformPaths)
{
var metadata = MetadataReference.CreateFromFile(path);
dependencyMetadata.Add(metadata);
}
var metadataContext = MetadataContext.Create(referenceMetadata, dependencyMetadata);
var assemblyEntries = new List <AssemblyEntry>();
foreach (var reference in metadataContext.Assemblies)
{
var entry = AssemblyEntry.Create(reference);
assemblyEntries.Add(entry);
}
frameworkEntries.Add(FrameworkEntry.Create(target.GetShortFolderName(), assemblyEntries));
}
}
return(PackageEntry.Create(id, version, frameworkEntries));
}
finally
{
foreach (var package in dependencies.Values)
{
package.Dispose();
}
}
}
