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(); } } }