public AssemblyTreeNode(AssemblyEntry assembly)
: base(assembly.Name)
{
Assembly = assembly;
ImageIndex = VSImage.Current.Assembly;
SelectedImageIndex = VSImage.Current.Assembly;
}
public static FrameworkEntry Index(string frameworkName, IEnumerable <string> assemblyPaths)
{
var references = new List <MetadataReference>();
foreach (var path in assemblyPaths)
{
var metadata = MetadataReference.CreateFromFile(path);
references.Add(metadata);
}
var metadataContext = MetadataContext.Create(references);
var assemblyEntries = new List <AssemblyEntry>();
foreach (var assembly in metadataContext.Assemblies)
{
var entry = AssemblyEntry.Create(assembly);
if (entry.Apis.Any())
{
assemblyEntries.Add(entry);
}
}
return(FrameworkEntry.Create(frameworkName, assemblyEntries));
}
private static Dependency ParseAssemblyName(AssemblyEntry assembly)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
try
{
var project = assembly.GithubUrl;
project = project.Replace("https://github.com/", "https://raw.githubusercontent.com/");
project = project.Replace("/blob/master/", "/master/");
using (var client = new WebClientEx())
{
var dependency = Dependency.FromAssemblyEntry(assembly);
var content = client.DownloadString(project);
var assemblyNameMatch = Regex.Match(content, "<AssemblyName>(?<name>.*?)</AssemblyName>");
dependency.Name = assemblyNameMatch.Groups["name"].Value;
return(dependency);
}
}
catch
{
Console.WriteLine($"Invalid: {assembly.Id} - {assembly.GithubUrl}");
}
return(null);
}
public static AssemblyEntry Flatten(List <AssemblyEntry> entries)
{
var entry = new AssemblyEntry
{
AssemblyRef = entries[0].AssemblyRef,
Domain = entries[0].Domain,
DomainIndex = 1,
Module = entries[0].Module,
Name = entries[0].Name
};
//store all types
var typedefEntries = new List <TypedefEntry>();
entries.ForEach(x => x.Types.ForEach(typedefEntries.Add));
//select unique type names
var typedefNames = new List <string>();
typedefEntries.ForEach(x => { if (!typedefNames.Contains(x.Name))
{
typedefNames.Add(x.Name);
}
});
//flatten type information
foreach (var name in typedefNames)
{
var typedefName = name;
entry.Types.Add(Flatten(entry, typedefEntries.FindAll(x => x.Name == typedefName)));
}
return(entry);
}
/// <summary>
/// 获取依赖的所有程序集的元数据集合
/// </summary>
/// <returns></returns>
private AssemblyEntry[] GetAssemblyEntries()
{
// 检查集合是否已存在
if (assemblyEntries != null)
{
return(assemblyEntries.ToArray());
}
// 获取运行时元数据
XRuntime xRuntime = manifest.Runtime;
if (xRuntime == null)
{
return(null);
}
// 获取所有依赖程序集元数据
XAssembly[] xAssemblies = xRuntime.Assemblies;
if (xAssemblies == null || xAssemblies.Length == 0)
{
return(null);
}
foreach (XAssembly xAssembly in xAssemblies)
{
if (assemblyEntries == null)
{
assemblyEntries = new List <AssemblyEntry>();
}
AssemblyEntry entry = new AssemblyEntry(xAssembly);
assemblyEntries.Add(entry);
}
return(assemblyEntries.ToArray());
}
public static async Task InstallAssembly(AssemblyEntry assembly, bool silent)
{
if (Config.Instance.SelectedProfile.InstalledAssemblies.Any(a => a.Name == assembly.Name))
{
return;
}
try
{
var projectName = Path.GetFileNameWithoutExtension(new Uri(assembly.GithubUrl).AbsolutePath);
var repositoryMatch = Regex.Match(assembly.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
var installer = new InstallerWindow {
Owner = MainWindow.Instance
};
if (silent)
{
await installer.ListAssemblies(repositoryUrl, true, true, HttpUtility.UrlDecode(projectName));
installer.Close();
return;
}
installer.ShowProgress(repositoryUrl, true, HttpUtility.UrlDecode(projectName));
installer.ShowDialog();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private AssemblyEntry AddAssembly(string name)
{
AssemblyEntry entry = new AssemblyEntry(name);
_entries.Add(entry);
return(entry);
}
void InitMenu()
{
AssemblyEntry entre = new AssemblyEntry();
List <Form> fs = entre.GatherFormObject();
List <string> items = new List <string>();
List <ToolStripItem> ul = new List <ToolStripItem>();
foreach (Form item in fs)
{
//ToolStripButton li = new ToolStripButton();//单独一项的菜单
//li.Text = item.Text;
ToolStripMenuItem li = new ToolStripMenuItem();
li.Name = item.Name;
li.Text = item.Text;
string menuItem = item.Tag as string;
if (!items.Contains(menuItem))
{//菜单项
items.Add(menuItem);
}
//这是第几项
int index = items.IndexOf(menuItem);
ToolStripItem ts = ul[index];
}
tsMenu.Items.AddRange(ul.ToArray());
}
private async Task EnsureAssemblyEntries( StorageFolder folder )
{
Contract.Requires( folder != null );
Contract.Ensures( Contract.Result<Task>() != null );
if ( initialized )
return;
var temp = new List<AssemblyEntry>();
foreach ( var file in await folder.GetFilesAsync() )
{
if ( file.FileType != ".dll" && file.FileType != ".exe" )
continue;
var name = new AssemblyName( Path.GetFileNameWithoutExtension( file.Name ) );
var assembly = Assembly.Load( name );
var entry = new AssemblyEntry( file.Path, assembly );
temp.Add( entry );
}
lock ( entries )
{
if ( initialized )
return;
initialized = true;
entries.ReplaceAll( temp );
}
}
public static void ResolveRuntimeDependencies(
string entryPoint,
string[] applicationDependencies,
string[] monoBclDirectories,
string[] resolutionOverrides,
string outputFile)
{
var assembly = new AssemblyEntry(entryPoint, AssemblyDefinition.ReadAssembly(entryPoint));
var dependencies = applicationDependencies
.Select(a => new AssemblyEntry(a, AssemblyDefinition.ReadAssembly(a)))
.ToArray();
var bcl = monoBclDirectories
.SelectMany(d => Directory.EnumerateFiles(d, "*.dll").Select(f => Path.Combine(d, f)))
.Select(a => new AssemblyEntry(a, AssemblyDefinition.ReadAssembly(a)))
.ToArray();
var assemblyResolutionContext = new AssemblyResolutionContext(
assembly,
dependencies,
bcl);
assemblyResolutionContext.ResolveAssemblies();
var paths = assemblyResolutionContext.Results.Select(r => r.Path);
File.WriteAllLines(outputFile, paths);
}
public static IEnumerable <string> ResolveRuntimeDependenciesCore(
string entryPoint,
string[] applicationDependencies,
string[] monoBclDirectories)
{
var assembly = new AssemblyEntry(entryPoint, AssemblyDefinition.ReadAssembly(entryPoint));
var dependencies = applicationDependencies
.Select(a => new AssemblyEntry(a, AssemblyDefinition.ReadAssembly(a)))
.ToArray();
var bcl = monoBclDirectories
.SelectMany(d => Directory.EnumerateFiles(d, "*.dll").Select(f => Path.Combine(d, f)))
.Select(a => new AssemblyEntry(a, AssemblyDefinition.ReadAssembly(a)))
.ToArray();
var assemblyResolutionContext = new AssemblyResolutionContext(
assembly,
dependencies,
bcl);
assemblyResolutionContext.ResolveAssemblies();
var paths = assemblyResolutionContext.Results.Select(r => r.Path);
return(paths.Concat(FindPdbs(paths)));
}
public NamespaceTreeNode(AssemblyEntry assembly, string namespacePath)
: base(namespacePath)
{
Namespace = namespacePath;
Assembly = assembly;
ImageIndex = VSImage.Current.Namespace;
SelectedImageIndex = VSImage.Current.Namespace;
}
public AssemblyResolutionContext(
AssemblyEntry entryAssembly,
Dictionary <string, AssemblyEntry> dependencies,
Dictionary <string, AssemblyEntry> bcl)
{
EntryAssembly = entryAssembly;
Dependencies = dependencies;
Bcl = bcl;
}
public AssemblyResolutionContext(
AssemblyEntry assembly,
AssemblyEntry[] dependencies,
AssemblyEntry[] bcl)
{
Assembly = assembly;
Dependencies = dependencies;
Bcl = bcl;
}
/// <summary>
/// 创建导出包
/// </summary>
/// <param name="bundle"></param>
/// <param name="asemblyEntry"></param>
/// <returns></returns>
internal static PrivilegedPackage Create(AbstractBundle bundle, AssemblyEntry asemblyEntry)
{
try
{
var package = new PrivilegedPackage(bundle, asemblyEntry);
package.Initialize();
return(package);
}
catch (Exception ex)
{
Log.Debug(ex);
}
return(null);
}
private static TypedefEntry Flatten(AssemblyEntry assembly, List <TypedefEntry> list)
{
var entry = list[0].Copy(assembly);
if (list.Count == 1)
{
return(entry);
}
foreach (var typedefEntry in list.GetRange(1, list.Count - 1))
{
CopyCoverage(entry, typedefEntry);
}
return(entry);
}
public void OnAfterDeserialize()
{
assemblies.Clear();
foreach (var assemblyData in serializedData)
{
AssemblyEntry entry = new AssemblyEntry
{
files = new Dictionary <string, Guid>(assemblyData.fileData.Length)
};
foreach (var file in assemblyData.fileData)
{
entry.files[file.name] = new Guid(file.guidData);
}
assemblies.Add(assemblyData.assemblyName, entry);
}
}
public static Dependency FromAssemblyEntry(AssemblyEntry assembly)
{
try
{
var repositoryMatch = Regex.Match(assembly.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var projectName = assembly.GithubUrl.Substring(assembly.GithubUrl.LastIndexOf("/") + 1);
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
return new Dependency { AssemblyEntry = assembly, Repository = repositoryUrl, Project = projectName, Name = assembly.Name, Description = assembly.Description };
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return null;
}
static Dictionary <string, AssemblyEntry> CreateAssemblyLookup(IEnumerable <string> assemblyPaths)
{
var dictionary = new Dictionary <string, AssemblyEntry>(StringComparer.Ordinal);
foreach (var path in assemblyPaths)
{
var assemblyName = AssemblyName.GetAssemblyName(path).Name;
if (dictionary.TryGetValue(assemblyName, out var previous))
{
throw new InvalidOperationException($"Multiple assemblies found with the same assembly name '{assemblyName}':" +
Environment.NewLine + string.Join(Environment.NewLine, previous, path));
}
dictionary[assemblyName] = new AssemblyEntry(path, assemblyName);
}
return(dictionary);
}
private static void AddAssembly(XContainer parent, AssemblyEntry assembly, string frameworkName = null)
{
var assemblyElement = new XElement("assembly",
frameworkName is null ? null : new XAttribute("fx", frameworkName),
new XAttribute("fingerprint", assembly.Fingerprint.ToString("N")),
new XAttribute("name", assembly.Identity.Name),
new XAttribute("publicKeyToken", assembly.Identity.GetPublicKeyTokenString()),
new XAttribute("version", assembly.Identity.Version.ToString())
);
if (assembly.PlatformSupportEntry is not null)
{
AddPlatformSupport(assemblyElement, assembly.PlatformSupportEntry);
}
if (assembly.PreviewRequirementEntry is not null)
{
AddPreviewRequirement(assemblyElement, assembly.PreviewRequirementEntry);
}
parent.Add(assemblyElement);
foreach (var api in assembly.AllApis())
{
var fingerprint = api.Fingerprint.ToString("N");
var syntaxElement = new XElement("syntax", new XAttribute("id", fingerprint));
assemblyElement.Add(syntaxElement);
syntaxElement.Add(api.Syntax);
if (api.ObsoletionEntry is not null)
{
AddObsoletion(assemblyElement, api.ObsoletionEntry, fingerprint);
}
if (api.PlatformSupportEntry is not null)
{
AddPlatformSupport(assemblyElement, api.PlatformSupportEntry, fingerprint);
}
if (api.PreviewRequirementEntry is not null)
{
AddPreviewRequirement(assemblyElement, api.PreviewRequirementEntry, fingerprint);
}
}
}
public AssemblyEntry GetAssemblyEntry(string assemblyPath, bool defaultIsChecked)
{
var assembly = Assembly.ReflectionOnlyLoadFrom(assemblyPath);
string fullName = assembly.FullName.Replace(", ", "\n");
var assemblyEntry = new AssemblyEntry
{
Path = assemblyPath,
Name = Path.GetFileName(assemblyPath),
Description = string.Format("{0}\nLoaded from: {1}", fullName, assemblyPath)
};
var namespaces = GetNamespaces(assemblyEntry, assemblyPath, defaultIsChecked);
assemblyEntry.InitializeChildren(namespaces);
return assemblyEntry;
}
/// <summary>
/// Unify an assembly name according to the fx retarget rules.
/// </summary>
/// <param name="assemblyName">The unify-from assembly name.</param>
/// <param name="unifiedVersion">The new version number.</param>
/// <param name="isPrerequisite">Whether this assembly will be available on target machines.</param>
/// <param name="isRedistRoot">May be true, false or null. Null means there was no IsRedistRoot in the redist list.</param>
/// <param name="redistName">Name of the corresponding Resist specified in the redist list.</param>
internal void GetInfo
(
AssemblyNameExtension assemblyName,
out Version unifiedVersion,
out bool isPrerequisite,
out bool?isRedistRoot,
out string redistName
)
{
unifiedVersion = assemblyName.Version;
isPrerequisite = false;
isRedistRoot = null;
redistName = null;
// Short-circuit in cases where there is no redist list.
if (_redistList == null)
{
return;
}
// If there's no version, for example in a simple name, then no remapping is possible,
// and this is not a prerequisite.
if (assemblyName.Version == null)
{
return;
}
AssemblyEntry highestVersionFromRedistList = FindHighestVersionInRedistList(assemblyName);
// Could not find the assembly in the redist list. Return as there has been no redist list unification
if (highestVersionFromRedistList == null)
{
return;
}
// Dont allow downgrading of reference version due to redist unification because this is automatic rather than something like an appconfig which
// has to be manually set. However if the major version is 255 then we do want to unify down the version number.
if (assemblyName.Version <= highestVersionFromRedistList.AssemblyNameExtension.Version || assemblyName.Version.Major == 255)
{
unifiedVersion = highestVersionFromRedistList.AssemblyNameExtension.Version;
isPrerequisite = _redistList.IsPrerequisiteAssembly(highestVersionFromRedistList.FullName);
isRedistRoot = _redistList.IsRedistRoot(highestVersionFromRedistList.FullName);
redistName = _redistList.RedistName(highestVersionFromRedistList.FullName);
}
}
public static LeagueSharpAssembly FromAssemblyEntry(AssemblyEntry entry)
{
try
{
var repositoryMatch = Regex.Match(entry.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
var repositoryDirectory = Path.Combine(Directories.RepositoriesDirectory, repositoryUrl.GetHashCode().ToString("X"), "trunk");
var path = Path.Combine(
repositoryDirectory,
entry.GithubUrl.Replace(repositoryUrl, string.Empty).Replace("/blob/master/", string.Empty).Replace("/", "\\"));
return(new LeagueSharpAssembly(entry.Name, path, repositoryUrl));
}
catch
{
return(null);
}
}
private FrameworkInformation GetFrameworkInformation(DirectoryInfo directory, NuGetFramework targetFramework)
{
var frameworkInfo = new FrameworkInformation();
frameworkInfo.Path = directory.FullName;
// The redist list contains the list of assemblies for this target framework
string redistList = Path.Combine(directory.FullName, "RedistList", "FrameworkList.xml");
Log.LogVerbose($"Loading Framework Information for {targetFramework}");
Log.LogVerbose($"Scanning {directory.FullName}");
if (File.Exists(redistList))
{
if (Log.IsEnabled(LogLevel.Verbose))
{
Log.LogVerbose($"Reading redist list from {redistList.Substring(directory.FullName.Length + 1)}");
}
frameworkInfo.RedistListPath = redistList;
using (var stream = File.OpenRead(redistList))
{
var frameworkList = XDocument.Load(stream);
foreach (var e in frameworkList.Root.Elements())
{
var assemblyName = e.Attribute("AssemblyName").Value;
var version = e.Attribute("Version")?.Value;
var entry = new AssemblyEntry();
entry.Version = version != null?Version.Parse(version) : null;
frameworkInfo.Assemblies.Add(assemblyName, entry);
Log.LogDebug($"Found assembly {assemblyName} {entry.Version}, in redist list");
}
var nameAttribute = frameworkList.Root.Attribute("Name");
frameworkInfo.Name = nameAttribute == null ? null : nameAttribute.Value;
}
}
return(frameworkInfo);
}
public static Dependency FromAssemblyEntry(AssemblyEntry assembly)
{
try
{
var repositoryMatch = Regex.Match(assembly.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var projectName = assembly.GithubUrl.Substring(assembly.GithubUrl.LastIndexOf("/") + 1);
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
return(new Dependency {
AssemblyEntry = assembly, Repository = repositoryUrl, Project = projectName, Name = assembly.Name, Description = assembly.Description
});
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
return(null);
}
public IEnumerable<NamespaceEntry> GetNamespaces(AssemblyEntry assemblyEntry, string assemblyPath, bool defaultIsChecked)
{
Argument.IsNotNullOrWhitespace("assemblyPath", assemblyPath);
var types = GetTypesFromAssembly(assemblyPath);
var namespaces = types.Select(x => new NamespaceEntry(assemblyEntry)
{
Path = assemblyPath,
Name = x.GetNamespace(),
Description = x.GetNamespace()
}).Distinct().OrderBy(e => e.Name).ToList();
foreach (var space in namespaces)
{
var namespaceTypes = GetTypes(space, assemblyPath, defaultIsChecked);
space.InitializeChildren(namespaceTypes);
}
return namespaces;
}
public static IEnumerable <string> ResolveRuntimeDependenciesCore(
string entryPoint,
IEnumerable <string> applicationDependencies,
IEnumerable <string> monoBclAssemblies)
{
var entryAssembly = new AssemblyEntry(entryPoint, GetAssemblyName(entryPoint));
var dependencies = CreateAssemblyLookup(applicationDependencies);
var bcl = CreateAssemblyLookup(monoBclAssemblies);
var assemblyResolutionContext = new AssemblyResolutionContext(
entryAssembly,
dependencies,
bcl);
assemblyResolutionContext.ResolveAssemblies();
var paths = assemblyResolutionContext.Results.Select(r => r.Path);
return(paths.Concat(FindPdbs(paths)));
/// <summary>
/// Called when receiving a report about an assembly
/// </summary>
/// <param name="domainIndex"></param>
/// <param name="domainName"></param>
/// <param name="assemblyName"></param>
/// <param name="moduleName"></param>
public void EnterAssembly(int domainIndex, string domainName, string assemblyName, string moduleName)
{
_symbolReader = _symbolReaderFactory.GetSymbolReader(moduleName);
if (_symbolReader != null)
{
var docs = _symbolReader.GetDocuments();
foreach (var doc in docs)
{
RegisterFile(doc.URL);
}
}
Report.Assemblies.Add(currentAssembly = new AssemblyEntry
{
AssemblyRef = Report.Assemblies.Count + 1,
Module = moduleName,
Name = assemblyName,
Domain = domainName,
DomainIndex = domainIndex
});
}
public static async Task InstallAssembly(AssemblyEntry assembly, bool silent)
{
if (Config.Instance.SelectedProfile.InstalledAssemblies.Any(a => a.Name == assembly.Name))
{
return;
}
try
{
var projectName = Path.GetFileNameWithoutExtension(new Uri(assembly.GithubUrl).AbsolutePath).WebDecode();
var repositoryMatch = Regex.Match(assembly.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
// HACK: :^)
var redirect = Config.Instance.BlockedRepositories.Where(r => r.HasRedirect).FirstOrDefault(r => repositoryUrl.StartsWith(r.Url));
if (redirect != null)
{
repositoryUrl = redirect.Redirect;
}
var installer = new InstallerWindow {
Owner = MainWindow.Instance
};
if (silent)
{
await installer.ListAssemblies(repositoryUrl, true, true, projectName);
installer.Close();
return;
}
installer.ShowProgress(repositoryUrl, true, projectName);
installer.ShowDialog();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void Select(AssemblyEntry assembly, string namespacePath)
{
SelectionHandlers.ForEach(x => x.Select(assembly, namespacePath));
}
public void Select(AssemblyEntry assembly)
{
SelectionHandlers.ForEach(x => x.Select(assembly));
}
public static async Task InstallAssembly(AssemblyEntry assembly, bool silent)
{
if (Config.Instance.SelectedProfile.InstalledAssemblies.Any(a => a.Name == assembly.Name))
{
return;
}
try
{
var projectName = Path.GetFileNameWithoutExtension(new Uri(assembly.GithubUrl).AbsolutePath);
var repositoryMatch = Regex.Match(assembly.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
var installer = new InstallerWindow { Owner = MainWindow.Instance };
if (silent)
{
await installer.ListAssemblies(repositoryUrl, true, true, HttpUtility.UrlDecode(projectName));
installer.Close();
return;
}
installer.ShowProgress(repositoryUrl, true, HttpUtility.UrlDecode(projectName));
installer.ShowDialog();
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public void Select(AssemblyEntry assembly)
{
Deselect();
}
private FrameworkInformation GetFrameworkInformation(DirectoryInfo directory, NuGetFramework targetFramework)
{
var frameworkInfo = new FrameworkInformation();
frameworkInfo.Path = directory.FullName;
// The redist list contains the list of assemblies for this target framework
string redistList = Path.Combine(directory.FullName, "RedistList", "FrameworkList.xml");
Log.LogVerbose($"Loading Framework Information for {targetFramework}");
Log.LogVerbose($"Scanning {directory.FullName}");
if (File.Exists(redistList))
{
if (Log.IsEnabled(LogLevel.Verbose))
{
Log.LogVerbose($"Reading redist list from {redistList.Substring(directory.FullName.Length + 1)}");
}
frameworkInfo.RedistListPath = redistList;
using (var stream = File.OpenRead(redistList))
{
var frameworkList = XDocument.Load(stream);
foreach (var e in frameworkList.Root.Elements())
{
var assemblyName = e.Attribute("AssemblyName").Value;
var version = e.Attribute("Version")?.Value;
var entry = new AssemblyEntry();
entry.Version = version != null ? Version.Parse(version) : null;
frameworkInfo.Assemblies.Add(assemblyName, entry);
Log.LogDebug($"Found assembly {assemblyName} {entry.Version}, in redist list");
}
var nameAttribute = frameworkList.Root.Attribute("Name");
frameworkInfo.Name = nameAttribute == null ? null : nameAttribute.Value;
}
}
return frameworkInfo;
}
private static Dependency ParseAssemblyName(AssemblyEntry assembly)
{
if (assembly == null)
{
throw new ArgumentNullException(nameof(assembly));
}
try
{
var project = assembly.GithubUrl;
project = project.Replace("https://github.com/", "https://raw.githubusercontent.com/");
project = project.Replace("/blob/master/", "/master/");
using (var client = new WebClientEx())
{
var dependency = Dependency.FromAssemblyEntry(assembly);
var content = client.DownloadString(project);
var assemblyNameMatch = Regex.Match(content, "<AssemblyName>(?<name>.*?)</AssemblyName>");
dependency.Name = assemblyNameMatch.Groups["name"].Value;
return dependency;
}
}
catch
{
Console.WriteLine($"Invalid: {assembly.Id} - {assembly.GithubUrl}");
}
return null;
}
private void PopulateCache()
{
#if DNX451
if (PlatformHelper.IsMono)
{
var mscorlibLocationOnThisRunningMonoInstance = typeof(object).GetTypeInfo().Assembly.Location;
var libPath = Path.GetDirectoryName(Path.GetDirectoryName(mscorlibLocationOnThisRunningMonoInstance));
// Mono is a bit inconsistent as .NET 4.5 and .NET 4.5.1 are the
// same folder
var supportedVersions = new Dictionary<string, string> {
{ "4.6", "4.5" },
{ "4.5.3", "4.5" },
{ "4.5.1", "4.5" },
{ "4.5", "4.5" },
{ "4.0", "4.0" }
};
// Temporary cache while enumerating assemblies in directories
var pathCache = new Dictionary<string, FrameworkInformation>();
foreach (var versionFolderPair in supportedVersions)
{
var targetFrameworkPath = Path.Combine(libPath, versionFolderPair.Value);
if (!Directory.Exists(targetFrameworkPath))
{
continue;
}
FrameworkInformation frameworkInfo;
if (!pathCache.TryGetValue(targetFrameworkPath, out frameworkInfo))
{
frameworkInfo = new FrameworkInformation();
frameworkInfo.Path = targetFrameworkPath;
var assemblies = new List<Tuple<string, string>>();
PopulateAssemblies(assemblies, targetFrameworkPath);
PopulateAssemblies(assemblies, Path.Combine(targetFrameworkPath, "Facades"));
foreach (var pair in assemblies)
{
var entry = new AssemblyEntry();
entry.Path = pair.Item2;
frameworkInfo.Assemblies[pair.Item1] = entry;
}
pathCache[targetFrameworkPath] = frameworkInfo;
}
var frameworkName = new NuGetFramework(FrameworkConstants.FrameworkIdentifiers.Net, new Version(versionFolderPair.Key));
_cache[frameworkName] = frameworkInfo;
}
// Not needed anymore
pathCache.Clear();
}
#endif
}
private void PopulateCache()
{
#if DNX451
if (PlatformHelper.IsMono)
{
var mscorlibLocationOnThisRunningMonoInstance = typeof(object).GetTypeInfo().Assembly.Location;
var libPath = Path.GetDirectoryName(Path.GetDirectoryName(mscorlibLocationOnThisRunningMonoInstance));
// Mono is a bit inconsistent as .NET 4.5 and .NET 4.5.1 are the
// same folder
var supportedVersions = new Dictionary <string, string> {
{ "4.6", "4.5" },
{ "4.5.3", "4.5" },
{ "4.5.1", "4.5" },
{ "4.5", "4.5" },
{ "4.0", "4.0" }
};
// Temporary cache while enumerating assemblies in directories
var pathCache = new Dictionary <string, FrameworkInformation>();
foreach (var versionFolderPair in supportedVersions)
{
var targetFrameworkPath = Path.Combine(libPath, versionFolderPair.Value);
if (!Directory.Exists(targetFrameworkPath))
{
continue;
}
FrameworkInformation frameworkInfo;
if (!pathCache.TryGetValue(targetFrameworkPath, out frameworkInfo))
{
frameworkInfo = new FrameworkInformation();
frameworkInfo.Path = targetFrameworkPath;
var assemblies = new List <Tuple <string, string> >();
PopulateAssemblies(assemblies, targetFrameworkPath);
PopulateAssemblies(assemblies, Path.Combine(targetFrameworkPath, "Facades"));
foreach (var pair in assemblies)
{
var entry = new AssemblyEntry();
entry.Path = pair.Item2;
frameworkInfo.Assemblies[pair.Item1] = entry;
}
pathCache[targetFrameworkPath] = frameworkInfo;
}
var frameworkName = new NuGetFramework(FrameworkConstants.FrameworkIdentifiers.Net, new Version(versionFolderPair.Key));
_cache[frameworkName] = frameworkInfo;
}
// Not needed anymore
pathCache.Clear();
}
#endif
}
public static LeagueSharpAssembly FromAssemblyEntry(AssemblyEntry entry)
{
try
{
var repositoryMatch = Regex.Match(entry.GithubUrl, @"^(http[s]?)://(?<host>.*?)/(?<author>.*?)/(?<repo>.*?)(/{1}|$)");
var repositoryUrl = $"https://{repositoryMatch.Groups["host"]}/{repositoryMatch.Groups["author"]}/{repositoryMatch.Groups["repo"]}";
var repositoryDirectory = Path.Combine(Directories.RepositoryDir, repositoryUrl.GetHashCode().ToString("X"), "trunk");
var path = Path.Combine(
repositoryDirectory,
entry.GithubUrl.Replace(repositoryUrl, "").Replace("/blob/master/", "").Replace("/", "\\"));
return new LeagueSharpAssembly(entry.Name, path, repositoryUrl);
}
catch
{
return null;
}
}
public void Select(AssemblyEntry assembly, string namespacePath)
{
Deselect();
}
public AssemblyEntry AddAssemblyEntry(AssemblyName assemblyReference)
{
AssemblyEntry entry = new AssemblyEntry(assemblyReference);
this._assemblyEntries.Add(entry);
this.SetSaveOnExit();
return entry;
}
private AssemblyEntry AddAssembly(string name) {
AssemblyEntry entry = new AssemblyEntry(name);
_entries.Add(entry);
return entry;
}
public AssemblyEntry AddAssemblyEntry(string name, string displayName)
{
AssemblyEntry entry = new AssemblyEntry(name, displayName);
this._assemblyEntries.Add(entry);
this.SetSaveOnExit();
return entry;
}
