static void ReadDependencies(DependencyCollection deps, DependencyCollection opDeps, XmlElement elem) { foreach (XmlElement dep in elem.SelectNodes("Dependencies/Addin")) { AddinDependency adep = new AddinDependency(); adep.AddinId = dep.GetAttribute("id"); string v = dep.GetAttribute("version"); if (v.Length != 0) { adep.Version = v; } deps.Add(adep); } foreach (XmlElement dep in elem.SelectNodes("Dependencies/Assembly")) { AssemblyDependency adep = new AssemblyDependency(); adep.FullName = dep.GetAttribute("name"); adep.Package = dep.GetAttribute("package"); deps.Add(adep); } foreach (XmlElement mod in elem.SelectNodes("Module")) { ReadDependencies(opDeps, opDeps, mod); } }
/// <summary> /// Adds an assembly dependency element if a suitable one does not already exist. /// </summary> /// <param name="name">The assembly name.</param> /// <param name="publicKeyToken">The assembly public key token, or null if none.</param> /// <param name="culture">The assembly culture.</param> /// <param name="architecture">The assembly processor architecture, or null if none.</param> /// <returns>The assembly dependency element.</returns> public AssemblyDependency AddAssemblyDependency(string name, string publicKeyToken, string culture, string architecture) { if (publicKeyToken != null && publicKeyToken.Length == 0) { throw new InvalidOperationException(); } AssemblyDependency assemblyDependency = assemblyDependencies.Find(x => x.AssemblyName == name && x.AssemblyPublicKeyToken == publicKeyToken && x.AssemblyCulture == culture && x.AssemblyProcessorArchitecture == architecture); if (assemblyDependency == null) { assemblyDependency = new AssemblyDependency(name) { AssemblyPublicKeyToken = publicKeyToken, AssemblyCulture = culture, AssemblyProcessorArchitecture = architecture }; assemblyDependencies.Add(assemblyDependency); } return(assemblyDependency); }
private static string GetReferenceName(AssemblyDependency reference) { if (reference == null) { return("(null)"); } return(Path.GetFileNameWithoutExtension(reference.Path)); }
/// <summary> /// Removes an assembly dependency. /// </summary> /// <param name="assemblyDependency">The assembly dependency to remove.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="assemblyDependency"/> is null.</exception> public void RemoveAssemblyDependency(AssemblyDependency assemblyDependency) { if (assemblyDependency == null) { throw new ArgumentNullException("assemblyDependency"); } assemblyDependencies.Remove(assemblyDependency); }
/// <summary> /// Adds an assembly dependency if it is not already in the configuration. /// </summary> /// <param name="assemblyDependency">The assembly dependency to add.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="assemblyDependency"/> is null.</exception> public void AddAssemblyDependency(AssemblyDependency assemblyDependency) { if (assemblyDependency == null) { throw new ArgumentNullException("assemblyDependency"); } if (!assemblyDependencies.Contains(assemblyDependency)) { assemblyDependencies.Add(assemblyDependency); } }
/// <summary> /// Initializes a new instance of the <see cref="AssemblyFile" /> class. /// </summary> /// <param name="reference">The reference.</param> /// <param name="targetModulePath">The target module path.</param> public AssemblyFile(AssemblyDependency reference, string targetModulePath) { Reference = reference; var targetModuleDirectory = System.IO.Path.GetDirectoryName(targetModulePath); var assemblyName = System.IO.Path.GetFileName(reference.Path); var assemblyPath = System.IO.Path.Combine(targetModuleDirectory, assemblyName); IsLocal = File.Exists(assemblyPath);// && assemblyPath != reference.Path; if (IsLocal) { Path = assemblyPath; } else { Path = reference.Path; } }
/// <summary> /// If this directive matches the specified reference, then an action is returned. /// </summary> /// <param name="assemblyReference">The assembly reference.</param> /// <param name="configuration">The configuration.</param> /// <returns></returns> public BlobAction?Matches(AssemblyDependency assemblyReference, string configuration) { if (assemblyReference.IsPrivate != Private) { return(null); } if (Configuration != null && !string.Equals(Configuration, configuration)) { return(null); } var assemblyFileName = GetAssemblyBaseName(assemblyReference); if (Name.WildcardMatch(assemblyFileName)) { return(Action); } return(null); }
/// <summary> /// Creates a copy of the assembly dependency information. /// </summary> /// <returns>The copy.</returns> public AssemblyDependency Copy() { AssemblyDependency copy = new AssemblyDependency(assemblyName); copy.applyPublisherPolicy = applyPublisherPolicy; copy.assemblyCulture = assemblyCulture; copy.assemblyProcessorArchitecture = assemblyProcessorArchitecture; copy.assemblyPublicKeyToken = assemblyPublicKeyToken; foreach (AssemblyBindingRedirect bindingRedirect in assemblyBindingRedirects) { copy.assemblyBindingRedirects.Add(bindingRedirect.Copy()); } foreach (AssemblyCodeBase codeBase in assemblyCodeBases) { copy.assemblyCodeBases.Add(codeBase.Copy()); } return(copy); }
public static void AddDllMapEntries( Assembly assembly, AssemblyDependency externalDependency) { var monoAssemblyPointerField = assembly.GetType().GetField( "_mono_assembly", BindingFlags.NonPublic | BindingFlags.Instance ); if (monoAssemblyPointerField == null) { return; } var monoAssemblyPointer = (IntPtr)monoAssemblyPointerField.GetValue(assembly); var monoImage = mono_assembly_get_image(monoAssemblyPointer); var location = externalDependency.Location; // If the P/Invoke path is an exact match (libfoo.dylib) mono_dllmap_insert(monoImage, location.Name, null, location, null); // If the P/Invoke is written as libfoo.dll. var dllPath = Path.ChangeExtension(location.Name, ".dll"); mono_dllmap_insert(monoImage, dllPath, null, location, null); // If the P/Invoke is written as libfoo var dllPathWithoutExtension = Path.GetFileNameWithoutExtension(location); mono_dllmap_insert(monoImage, dllPathWithoutExtension, null, location, null); // If the P/Invoke is written as foo.dll or foo if (dllPath.StartsWith("lib", StringComparison.OrdinalIgnoreCase)) { var nonLibPath = dllPath.Substring(3); var nonLibWithoutExtension = dllPathWithoutExtension.Substring(3); mono_dllmap_insert(monoImage, nonLibPath, null, location, null); mono_dllmap_insert(monoImage, nonLibWithoutExtension, null, location, null); } }
private void OnDependencySelected(object sender, MouseButtonEventArgs e) { AssemblyDependency dependency = ((ListViewItem)sender).Content as AssemblyDependency; if (dependency == null) { return; } try { var locDir = Path.GetDirectoryName(_prober.Location); Process.Start(new ProcessStartInfo { FileName = _exePath, Arguments = string.Format("{0} \"{1}\"", AssemblyKeyword, dependency.DisplayName), WorkingDirectory = string.IsNullOrWhiteSpace(locDir) ? Environment.CurrentDirectory : locDir }); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error", MessageBoxButton.OK, MessageBoxImage.Error); } }
/// <summary> /// Adds a binding to the configuration for the specified assembly. /// </summary> /// <remarks> /// <para> /// Depending on how the binding is configured, this method will add an assembly dependency /// record and possibly an assembly qualification record. /// </para> /// </remarks> /// <param name="assemblyBinding">The assembly binding.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="assemblyBinding"/> is null.</exception> public void AddAssemblyBinding(AssemblyBinding assemblyBinding) { if (assemblyBinding == null) { throw new ArgumentNullException("assemblyBinding"); } AssemblyName assemblyName = assemblyBinding.AssemblyName; byte[] publicKeyTokenBytes = assemblyName.GetPublicKeyToken(); string publicKeyToken = publicKeyTokenBytes != null && publicKeyTokenBytes.Length != 0 ? ToHex(publicKeyTokenBytes) : null; if (assemblyBinding.QualifyPartialName && publicKeyToken != null) { AddAssemblyQualification(assemblyName.Name, assemblyName.FullName); } AssemblyDependency assemblyDependency = AddAssemblyDependency( assemblyName.Name, publicKeyToken, AssemblyUtils.GetAssemblyNameCulture(assemblyName), GetProcessorArchitectureName(assemblyName.ProcessorArchitecture)); foreach (AssemblyBinding.BindingRedirect bindingRedirect in assemblyBinding.BindingRedirects) { assemblyDependency.AddAssemblyBindingRedirect(bindingRedirect.OldVersion, assemblyName.Version.ToString()); } // Note: If unsigned assembly appears outside of appbase then we get an exception: // "The private assembly was located outside the appbase directory." if (assemblyBinding.CodeBase != null && publicKeyToken != null) { assemblyDependency.AddAssemblyCodeBase(assemblyName.Version.ToString(), assemblyBinding.CodeBase.ToString()); } assemblyDependency.ApplyPublisherPolicy = assemblyBinding.ApplyPublisherPolicy; }
/// <summary> /// Adds an assembly dependency element if a suitable one does not already exist. /// </summary> /// <param name="name">The assembly name.</param> /// <param name="publicKeyToken">The assembly public key token, or null if none.</param> /// <param name="culture">The assembly culture.</param> /// <param name="architecture">The assembly processor architecture, or null if none.</param> /// <returns>The assembly dependency element.</returns> public AssemblyDependency AddAssemblyDependency(string name, string publicKeyToken, string culture, string architecture) { if (publicKeyToken != null && publicKeyToken.Length == 0) throw new InvalidOperationException(); AssemblyDependency assemblyDependency = assemblyDependencies.Find(x => x.AssemblyName == name && x.AssemblyPublicKeyToken == publicKeyToken && x.AssemblyCulture == culture && x.AssemblyProcessorArchitecture == architecture); if (assemblyDependency == null) { assemblyDependency = new AssemblyDependency(name) { AssemblyPublicKeyToken = publicKeyToken, AssemblyCulture = culture, AssemblyProcessorArchitecture = architecture }; assemblyDependencies.Add(assemblyDependency); } return assemblyDependency; }
/// <summary> /// Adds an assembly dependency if it is not already in the configuration. /// </summary> /// <param name="assemblyDependency">The assembly dependency to add.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="assemblyDependency"/> is null.</exception> public void AddAssemblyDependency(AssemblyDependency assemblyDependency) { if (assemblyDependency == null) throw new ArgumentNullException("assemblyDependency"); if (!assemblyDependencies.Contains(assemblyDependency)) assemblyDependencies.Add(assemblyDependency); }
public static void Main() { AssemblyDependency.UsedToKeepReferenceAtCompileTime(); Helper(); }
/// <summary> /// Removes an assembly dependency. /// </summary> /// <param name="assemblyDependency">The assembly dependency to remove.</param> /// <exception cref="ArgumentNullException">Thrown if <paramref name="assemblyDependency"/> is null.</exception> public void RemoveAssemblyDependency(AssemblyDependency assemblyDependency) { if (assemblyDependency == null) throw new ArgumentNullException("assemblyDependency"); assemblyDependencies.Remove(assemblyDependency); }
/// <summary> /// Creates a copy of the assembly dependency information. /// </summary> /// <returns>The copy.</returns> public AssemblyDependency Copy() { AssemblyDependency copy = new AssemblyDependency(assemblyName); copy.applyPublisherPolicy = applyPublisherPolicy; copy.assemblyCulture = assemblyCulture; copy.assemblyProcessorArchitecture = assemblyProcessorArchitecture; copy.assemblyPublicKeyToken = assemblyPublicKeyToken; foreach (AssemblyBindingRedirect bindingRedirect in assemblyBindingRedirects) copy.assemblyBindingRedirects.Add(bindingRedirect.Copy()); foreach (AssemblyCodeBase codeBase in assemblyCodeBases) copy.assemblyCodeBases.Add(codeBase.Copy()); return copy; }
private static string GetAssemblyBaseName(AssemblyDependency assemblyReference) { return(Path.GetFileNameWithoutExtension(assemblyReference.Path)); }