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