static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
Assembly asm;
if (!AssemblyCache.TryGetValue(args.Name, out asm))
{
var name = args.Name;
var index = name.IndexOf(",");
if (index > 0)
name = name.Substring(0, index);
foreach (var path in BinPath)
{
var filename = name + ".dll";
var filepath = Path.Combine(path, filename);
if (!File.Exists(filepath))
{
filepath = Path.ChangeExtension(filepath, ".exe");
}
if (File.Exists(filepath))
{
asm = Assembly.LoadFrom(filepath);
if (asm != null)
{
AssemblyCache[asm.FullName] = asm;
Console.WriteLine("Assembly resolver found assembly "+asm.Location);
break;
}
}
}
}
return asm;
}
private static Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
var name = args.Name.Split(',')[0];
if (name.Equals("Microsoft.UpdateServices.Administration"))
{
// Microsoft changed version numbers when putting WSUS Admin API into RSAT.
// Need to try and maintain backward compatability.
if (!alreadyTriedRedirect)
{
alreadyTriedRedirect = true;
var programFiles = Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles);
if (!programFiles.EndsWith(@"\"))
{
programFiles = programFiles + @"\";
}
redirect = Assembly.LoadFrom(string.Format("{0}Update Services\\Api\\Microsoft.UpdateServices.Administration.dll", programFiles));
}
return redirect;
}
return null;
}
private static Assembly OnResolveAssembly(object sender, ResolveEventArgs args)
{
Assembly cachedAsm;
if (loadedAsmsCache.TryGetValue(args.Name, out cachedAsm))
return cachedAsm;
Assembly executingAssembly = Assembly.GetExecutingAssembly();
AssemblyName assemblyName = new AssemblyName(args.Name);
string path = assemblyName.Name + ".dll";
if (assemblyName.CultureInfo != null && assemblyName.CultureInfo.Equals(CultureInfo.InvariantCulture) == false)
{
path = String.Format(@"{0}\{1}", assemblyName.CultureInfo, path);
}
using (Stream stream = executingAssembly.GetManifestResourceStream(path))
{
if (stream == null)
return null;
byte[] assemblyRawBytes = new byte[stream.Length];
stream.Read(assemblyRawBytes, 0, assemblyRawBytes.Length);
var loadedAsm = Assembly.Load(assemblyRawBytes);
loadedAsmsCache.Add(args.Name, loadedAsm);
return loadedAsm;
}
}
public Assembly OnAssemblyResolve(object sender,
ResolveEventArgs args)
{
if (!(sender is AppDomain))
return null;
string[] pathList = new[]
{
Path.Combine(Directory.GetCurrentDirectory(), "bin"),
Path.Combine(Directory.GetCurrentDirectory(), PathToSearch),
Path.Combine(Directory.GetCurrentDirectory(),
Path.Combine(PathToSearch, "Scripts")),
Directory.GetCurrentDirectory(),
};
string assemblyName = args.Name;
if (assemblyName.IndexOf(",") != -1)
assemblyName = args.Name.Substring(0, args.Name.IndexOf(","));
foreach (string s in pathList)
{
string path = Path.Combine(s, assemblyName) + ".dll";
if (File.Exists(path))
return Assembly.Load(AssemblyName.GetAssemblyName(path));
}
return null;
}
private static Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
{
lock (syncRoot)
{
if (checkedAssemblies.Add(args.Name))
{
var assemblyName = new AssemblyName(args.Name);
if (!assemblyName.Name.EndsWith(".resources"))
{
var stream = typeof(AssemblyResolver).Assembly.GetManifestResourceStream(typeof(AssemblyResolver), assemblyName.Name + ".pkg");
if (stream != null)
{
using (var package = Package.Open(stream))
{
var partUri = PackUriHelper.CreatePartUri(new Uri(assemblyName.Name + ".dll", UriKind.Relative));
if (package.PartExists(partUri))
{
var part = package.GetPart(partUri);
var ms = new MemoryStream();
part.GetStream().CopyTo(ms);
return Assembly.Load(ms.ToArray());
}
}
}
}
}
return null;
}
}
private static Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
var requestedName = new AssemblyName(args.Name);
if (knownAssemblies.ContainsKey(requestedName.Name))
{
foreach (var item in knownAssemblies[requestedName.Name])
{
if (requestedName.Name == item.Item1.Name &&
(requestedName.Version == null || requestedName.Version == item.Item1.Version) &&
(requestedName.CultureInfo == null || requestedName.CultureInfo == item.Item1.CultureInfo) &&
(requestedName.GetPublicKey() == null || requestedName.GetPublicKey() == item.Item1.GetPublicKey()))
{
var path = Path.Combine(item.Item2, requestedName.Name + ".dll");
if (File.Exists(path))
return Assembly.LoadFrom(path);
}
}
}
foreach (var directory in searchDirectories)
{
var path = Path.Combine(directory, requestedName.Name + ".dll");
if (File.Exists(path))
return Assembly.LoadFrom(path);
}
return null;
}
Assembly AssemblyResolve(object sender, ResolveEventArgs e)
{
AssemblyName name = new AssemblyName(e.Name);
LoggingService.Debug("ProjectContentRegistry.AssemblyResolve " + e.Name);
string path = Path.Combine(lookupDirectory, name.Name);
if (File.Exists(path + ".dll")) {
return Assembly.ReflectionOnlyLoadFrom(path + ".dll");
}
if (File.Exists(path + ".exe")) {
return Assembly.ReflectionOnlyLoadFrom(path + ".exe");
}
if (File.Exists(path)) {
return Assembly.ReflectionOnlyLoadFrom(path);
}
try {
LoggingService.Debug("AssemblyResolve trying ReflectionOnlyLoad");
return Assembly.ReflectionOnlyLoad(e.Name);
} catch (FileNotFoundException) {
LoggingService.Warn("AssemblyResolve: ReflectionOnlyLoad failed for " + e.Name);
// We can't get the assembly we want.
// But propably we can get a similar version of it.
DomAssemblyName fixedName = GacInterop.FindBestMatchingAssemblyName(e.Name);
LoggingService.Info("AssemblyResolve: FixedName: " + fixedName);
return Assembly.ReflectionOnlyLoad(fixedName.FullName);
}
}
Assembly AssemblyResolve(object sender, ResolveEventArgs args) {
var assembly = Get(args.Name);
if (assembly != null)
return assembly;
var asmName = new AssemblyName(args.Name);
foreach (var path in assemblySearchPaths) {
foreach (var ext in assemblyExtensions) {
try {
var filename = Path.Combine(path, asmName.Name + ext);
if (!new FileInfo(filename).Exists)
continue;
AddConfigFile(filename + ".config");
return AddAssembly(Assembly.LoadFile(filename));
}
catch (IOException) {
}
catch (BadImageFormatException) {
}
catch (ArgumentException) {
}
catch (NotSupportedException) {
}
catch (UnauthorizedAccessException) {
}
catch (System.Security.SecurityException) {
}
}
}
return null;
}
static Assembly OnAppDomainAssemblyResolve(object sender, ResolveEventArgs args)
{
if (assemblyResolveReentrant)
{
return null;
}
assemblyResolveReentrant = true;
try
{
try
{
return Assembly.Load(args.Name);
}
catch (FileNotFoundException)
{
return null;
}
catch (FileLoadException)
{
return null;
}
catch (BadImageFormatException)
{
return null;
}
}
finally
{
assemblyResolveReentrant = false;
}
}
public static Assembly HandleAssemblyResolve(object sender, ResolveEventArgs args)
{
string assemblyName = new AssemblyName(args.Name).Name + ".dll";
if(assemblyName.Contains(".resources"))
{
//Console.WriteLine("AssemblyResolve: {0}", assemblyName);
return null;
}
string fullAssemblyName = string.Empty;
foreach(var manifestResource in Assembly.GetExecutingAssembly().GetManifestResourceNames())
{
if(manifestResource.Contains(assemblyName))
{
fullAssemblyName = manifestResource;
break;
}
}
if(fullAssemblyName == string.Empty)
return null;
using(var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(fullAssemblyName))
{
byte[] assemblyData = new byte[stream.Length];
stream.Read(assemblyData, 0, assemblyData.Length);
return Assembly.Load(assemblyData);
}
}
// This method loads Assemblys such as the SharpZipLib which is needed for bz2-files.
// But only when they're needed. That makes it so special...
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
if (!args.Name.Contains("ICSharpCode.SharpZipLib"))
{
return null;
}
Assembly result = null;
using (Stream embedded = Assembly.GetExecutingAssembly().GetManifestResourceStream(typeof(Program).Namespace + ".ICSharpCode.SharpZipLib.dll"))
{
byte[] buffer = new byte[embedded.Length];
int length = buffer.Length;
int offset = 0;
while (length > 0)
{
int read = embedded.Read(buffer, offset, length);
if (read == 0)
{
break;
}
length -= read;
offset += read;
}
result = Assembly.Load(buffer);
}
return result;
}
private static Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
{
try {
// This handler is called only when the common language runtime tries to bind to the assembly and fails.
// Retrieve the assembly in addin directoriess
int index = args.Name.IndexOf(",");
string assemblyName = index >= 0 ? args.Name.Substring(0, index) : args.Name;
Assembly assembly = null;
string path = null;
for (int i = 0; i < addinDirectories.Count; i++) {
string dir = addinDirectories[i];
string tempPath = Path.Combine(dir, assemblyName + ".dll");
if(File.Exists(tempPath))
{
path = tempPath;
break;
}
}
if(path != null)
assembly = System.Reflection.Assembly.LoadFrom(path);
return assembly;
}
catch(Exception ex)
{
MessageService.ShowError("The assembly '" + args.Name + "' could not be loaded:\n" + ex.ToString());
}
return null;
}
static Assembly LoadFromSameFolder(object sender, ResolveEventArgs args)
{
string assemblyPath = Path.Combine(_path, new AssemblyName(args.Name).Name + ".dll");
if (File.Exists(assemblyPath) == false) return null;
Assembly assembly = Assembly.LoadFrom(assemblyPath);
return assembly;
}
/// <summary>
/// Handler to the ApplicationDomain's AssemblyResolve event.
/// If an assembly's location cannot be resolved, an exception is
/// thrown. Failure to resolve an assembly will leave Dynamo in
/// a bad state, so we should throw an exception here which gets caught
/// by our unhandled exception handler and presents the crash dialogue.
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
/// <returns></returns>
public static Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
try
{
// First check the core path
string assemblyPath = Path.Combine(DynamoPathManager.Instance.MainExecPath, new AssemblyName(args.Name).Name + ".dll");
if (File.Exists(assemblyPath))
{
return Assembly.LoadFrom(assemblyPath);
}
// Then check all additional resolution paths
foreach (var addPath in DynamoPathManager.Instance.AdditionalResolutionPaths)
{
assemblyPath = Path.Combine(addPath, new AssemblyName(args.Name).Name + ".dll");
if (File.Exists(assemblyPath))
{
return Assembly.LoadFrom(assemblyPath);
}
}
return null;
}
catch (Exception ex)
{
throw new Exception(string.Format("There location of the assembly, {0} could not be resolved for loading.", args.Name), ex);
}
}
static System.Reflection.Assembly Resolver(object sender, ResolveEventArgs args)
{
//This handler is called only when the common language runtime tries to bind to the assembly and fails.
//Load required DLL form a embeded Ressources
Assembly a1 = Assembly.GetExecutingAssembly(); // Get Executing Assembly
//Find the Name of the missing Dll to Load
string Name = a1.GetName().Name + ".DLL." + args.Name.Split(',')[0];
//Get a List of Embeded Ressources
string[] str = a1.GetManifestResourceNames();
byte[] block = null;
for (int i = 0; i < str.Length; i++)
{
if (str[i].StartsWith(Name))//Does not check for the Extension, SO multiple extension are a not OK. Or if the File Name does not match the Namespace
{
Stream s = a1.GetManifestResourceStream(str[i]);
block = new byte[s.Length];
s.Read(block, 0, block.Length);
break;
}
}
Assembly a2 = Assembly.Load(block);
return a2;
}
public static Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
var name = new AssemblyName(args.Name).Name.ToLowerInvariant();
var existingAssembly = ReadExistingAssembly(name);
if (existingAssembly != null)
{
return existingAssembly;
}
var prefix = string.Concat("costura.", name);
var executingAssembly = Assembly.GetExecutingAssembly();
byte[] assemblyData;
using (var assemblyStream = GetAssemblyStream(executingAssembly, prefix))
{
if (assemblyStream == null)
{
return null;
}
assemblyData = ReadStream(assemblyStream);
}
using (var pdbStream = GetDebugStream(executingAssembly, prefix))
{
if (pdbStream != null)
{
var pdbData = ReadStream(pdbStream);
return Assembly.Load(assemblyData, pdbData);
}
}
return Assembly.Load(assemblyData);
}
static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
if (args.Name.StartsWith("System.Data.SQLite")) {
return sqliteAssembly;
}
return null;
}
static Assembly Resolve(object sender, ResolveEventArgs e) {
byte[] b = Encoding.UTF8.GetBytes(new AssemblyName(e.Name).FullName.ToUpperInvariant());
Stream m = null;
if (b.Length + 4 <= key.Length) {
for (int i = 0; i < b.Length; i++)
b[i] *= key[i + 4];
string n = Convert.ToBase64String(b);
m = Assembly.GetEntryAssembly().GetManifestResourceStream(n);
}
if (m != null) {
var d = new uint[m.Length >> 2];
var t = new byte[0x100];
int r;
int o = 0;
while ((r = m.Read(t, 0, 0x100)) > 0) {
Buffer.BlockCopy(t, 0, d, o, r);
o += r;
}
uint s = 0x6fff61;
foreach (byte c in b)
s = s * 0x5e3f1f + c;
GCHandle h = Decrypt(d, s);
var f = (byte[])h.Target;
Assembly a = Assembly.Load(f);
Array.Clear(f, 0, f.Length);
h.Free();
Array.Clear(d, 0, d.Length);
return a;
}
return null;
}
public static Assembly ResolveAssemblyHandler (object sender, ResolveEventArgs e)
{
if (e.Name != "System.Web_test")
return null;
return Assembly.GetExecutingAssembly ();
}
void eCX()
{
System.Web.Security.MembershipPasswordException qTY = new System.Web.Security.MembershipPasswordException();
System.Exception tOOK = new System.Exception();
System.Threading.SynchronizationContext MaH = new System.Threading.SynchronizationContext();
System.Web.UI.WebControls.WebParts.PageCatalogPart ayRmRe = new System.Web.UI.WebControls.WebParts.PageCatalogPart();
System.Web.Security.DefaultAuthenticationModule Exmkenb = new System.Web.Security.DefaultAuthenticationModule();
System.Web.SessionState.SessionStateModule TmbqbT = new System.Web.SessionState.SessionStateModule();
System.ResolveEventArgs cGQ = new System.ResolveEventArgs("oYfQTFJiOZSVw");
System.Web.UI.ControlValuePropertyAttribute LIX = new System.Web.UI.ControlValuePropertyAttribute("zCbHRvFJUat", 910602186);
System.Runtime.InteropServices.SetWin32ContextInIDispatchAttribute rfLFm = new System.Runtime.InteropServices.SetWin32ContextInIDispatchAttribute();
System.Net.HttpListenerException tIez = new System.Net.HttpListenerException(2135436060, "NJgG");
System.WeakReference mKrXQJ = new System.WeakReference(1723804374);
System.Web.Configuration.OutputCacheProfile atJh = new System.Web.Configuration.OutputCacheProfile("ArZxwFnPdDdni");
System.ParamArrayAttribute TyUXndy = new System.ParamArrayAttribute();
System.Runtime.Serialization.OnDeserializingAttribute lVgFArZ = new System.Runtime.Serialization.OnDeserializingAttribute();
System.Data.SqlTypes.TypeNumericSchemaImporterExtension QbBDir = new System.Data.SqlTypes.TypeNumericSchemaImporterExtension();
System.Windows.Forms.ListViewGroup MvRc = new System.Windows.Forms.ListViewGroup("ELItUnvMGVWDmEGD");
System.ComponentModel.Design.CheckoutException NwMcuF = new System.ComponentModel.Design.CheckoutException("QdlJvFMgCKYGHpcTb");
System.Globalization.RegionInfo tAChNgq = new System.Globalization.RegionInfo(2015922813);
System.Web.UI.WebControls.ValidationSummary kcldBEv = new System.Web.UI.WebControls.ValidationSummary();
System.Windows.Forms.RelatedImageListAttribute PFSRAV = new System.Windows.Forms.RelatedImageListAttribute("ZtfKTawcAmWr");
System.Web.UI.WebControls.TableSectionStyle ehekxI = new System.Web.UI.WebControls.TableSectionStyle();
System.ComponentModel.ByteConverter oodnW = new System.ComponentModel.ByteConverter();
System.Web.UI.WebControls.DetailsViewPageEventArgs NFia = new System.Web.UI.WebControls.DetailsViewPageEventArgs(599344366);
System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNotation Savfrr = new System.Runtime.Remoting.Metadata.W3cXsd2001.SoapNotation();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private static Assembly LoadAssemblyFromPackagePath (object sender, ResolveEventArgs args)
{
try
{
string packagePath = Path.GetDirectoryName (Assembly.GetExecutingAssembly ().Location);
string assemblyFilename = args.Name;
int i = assemblyFilename.IndexOf (',');
if (i != -1)
{
assemblyFilename = assemblyFilename.Substring (0, i);
}
string assemblyPath = Path.Combine (packagePath, assemblyFilename + ".dll");
if (!File.Exists (assemblyPath))
{
return null;
}
Assembly assembly = Assembly.LoadFrom (assemblyPath);
return assembly;
}
catch (Exception e)
{
LoggingUtils.HandleException (e);
return null;
}
}
static System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
//
if (!args.Name.Contains("SDNSAPI"))
return null;
//
string connectorKeyName = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{33A002DC-D590-4527-B98E-3B9D6F4FC5DC}";
string connectorLocation = String.Empty;
//
if (PInvoke.RegistryHive.HKLM.SubKeyExists_x86(connectorKeyName))
{
connectorLocation = PInvoke.RegistryHive.HKLM.GetSubKeyValue_x86(connectorKeyName, "InstallLocation");
}
//
if (String.IsNullOrEmpty(connectorLocation))
{
Log.WriteInfo("SimpleDNS API library location is either null or empty");
return null;
}
//
string assemblyFile = Path.Combine(connectorLocation, args.Name.Split(',')[0] + ".dll");
//
Log.WriteInfo(assemblyFile);
//
if (!File.Exists(assemblyFile))
{
Log.WriteInfo("SimpleDNS API library could not be found or does not exist");
return null;
}
//
return Assembly.LoadFrom(assemblyFile);
}
private System.Reflection.Assembly HandleResolve(object sender, ResolveEventArgs args)
{
if (args.Name.StartsWith("FSharp.Core,", StringComparison.OrdinalIgnoreCase))
{
#if DEBUG
Logger.TraceInformation("[{0}]: HandleResolve '{1}'", GetType().Name, args.Name);
#endif
lock (l)
{
if (inner)
{
return null;
}
inner = true;
}
try
{
return System.Reflection.Assembly.Load("FSharp.Core");
}
finally
{
lock(l)
{
inner = false;
}
}
}
return null;
}
public Assembly Resolver(object sender, ResolveEventArgs args)
{
lock (this)
{
Assembly assembly;
AssemblyName askedAssembly = new AssemblyName(args.Name);
string[] fields = args.Name.Split(',');
string name = fields[0];
string culture = fields[2];
// failing to ignore queries for satellite resource assemblies or using [assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.MainAssembly)]
// in AssemblyInfo.cs will crash the program on non en-US based system cultures. detailed discussion: http://connect.microsoft.com/VisualStudio/feedback/details/526836/wpf-appdomain-assemblyresolve-being-called-when-it-shouldnt
if (name.EndsWith(".resources") && !culture.EndsWith("neutral")) return null;
string resourceName = string.Format("BlizzTV.Assets.Assemblies.{0}.dll", askedAssembly.Name);
using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
{
if (stream == null)
{
LogManager.Instance.Write(LogMessageTypes.Fatal, string.Format("Can not resolve asked assembly: {0}", askedAssembly));
MessageBox.Show(i18n.CanNotLoadRequiredAssembliesMessage, i18n.CanNotLoadRequiredAssembliesTitle, MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(-1);
}
byte[] assemblyData = new byte[stream.Length];
stream.Read(assemblyData, 0, assemblyData.Length);
assembly = Assembly.Load(assemblyData);
}
LogManager.Instance.Write(LogMessageTypes.Trace, "Loaded embedded assembly: " + askedAssembly);
return assembly;
}
}
private static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
//This handler is called only when the common language runtime tries to bind to the assembly and fails.
//Retrieve the list of referenced assemblies in an array of AssemblyName.
Assembly MyAssembly, objExecutingAssemblies;
string strTempAssmbPath = "";
objExecutingAssemblies = Assembly.GetExecutingAssembly();
AssemblyName[] arrReferencedAssmbNames = objExecutingAssemblies.GetReferencedAssemblies();
//Loop through the array of referenced assembly names.
foreach (AssemblyName strAssmbName in arrReferencedAssmbNames)
{
//Check for the assembly names that have raised the "AssemblyResolve" event.
if (strAssmbName.FullName.Substring(0, strAssmbName.FullName.IndexOf(",")) == args.Name.Substring(0, args.Name.IndexOf(",")))
{
//Build the path of the assembly from where it has to be loaded.
strTempAssmbPath = Util.GetRalativePath(@"cef\" + args.Name.Substring(0, args.Name.IndexOf(",")) + ".dll");
break;
}
}
//Load the assembly from the specified path.
MyAssembly = Assembly.LoadFrom(strTempAssmbPath);
//Return the loaded assembly.
return MyAssembly;
}
Assembly ResolveAssembly(object sender, ResolveEventArgs args)
{
var appDirectory = AppDomain.CurrentDomain.BaseDirectory;
var modulesDirectory = Path.Combine(appDirectory, "Modules");
var filename = Path.Combine(modulesDirectory, new AssemblyName(args.Name).Name + ".dll");
return Assembly.Load(File.ReadAllBytes(filename));
}
public System.Reflection.Assembly Resolve (object sender, ResolveEventArgs args)
{
var location = parent.GetAssemblyPath (args.Name);
if (location != null)
return System.Reflection.Assembly.LoadFrom (location);
return null;
}
private static Assembly EmbeddedAssemblyResolver(object sender, ResolveEventArgs args)
{
try
{
var assemblyName = new AssemblyName(args.Name);
String resourceName = Assembly.GetExecutingAssembly().FullName.Split(',').First() + "." + assemblyName.Name + ".dll";
using (var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourceName))
{
if (stream != null)
{
Byte[] assemblyData = new Byte[stream.Length];
stream.Read(assemblyData, 0, assemblyData.Length);
if (Array.Exists(UnmanagedAssemblies, element => element.Equals(assemblyName.Name)))
{
String tempFile = Path.GetTempFileName();
File.WriteAllBytes(tempFile, assemblyData);
Console.WriteLine("[" + Thread.CurrentThread.ManagedThreadId + "-" + Thread.CurrentThread.Name + "] Loading assembly " + assemblyName.Name + " from " + tempFile);
return Assembly.LoadFile(tempFile);
}
else
{
return Assembly.Load(assemblyData);
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + (ex.InnerException != null ? " : " + ex.InnerException.Message : ""), "Program Failed to access Assembly " + args.Name,
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return null;
}
static Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
{
String s = args.Name.Substring(0,args.Name.IndexOf(",")) + ".dll";
Console.WriteLine(s);
return Assembly.LoadFile(s);
}
private Assembly OrigoDomainOnAssemblyResolve(object sender, ResolveEventArgs args)
{
try
{
Assembly assembly = Assembly.Load(args.Name);
if (assembly != null)
return assembly;
}
catch
{
// ignore load error
}
// *** Try to load by filename - split out the filename of the full assembly name
// *** and append the base path of the original assembly (ie. look in the same dir)
// *** NOTE: this doesn't account for special search paths but then that never
// worked before either.
string[] parts = args.Name.Split(',');
string file = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\" + parts[0].Trim() +
".dll";
if (File.Exists(file))
{
return Assembly.LoadFrom(file);
}
return null;
}
Assembly AssemblyResolve(object sender, ResolveEventArgs args)
{
// this should only be called to resolve OnlineVideos.dll -> return it regardless of the version, only the name "OnlineVideos"
AssemblyName an = new AssemblyName(args.Name);
var asm = (sender as AppDomain).GetAssemblies().FirstOrDefault(a => a.GetName().Name == an.Name);
return asm;
}
public Assembly OnExecuted(object sender, System.ResolveEventArgs e)
{
Trace.TraceInformation("End " + e.Name);
if (!(e.Name.Contains("Reader") || e.Name.Contains("DataContext")) && !KeepConnected)
{
CloseConnection();
}
return(null);
}
private static System.Reflection.Assembly CustomResolve(object sender, System.ResolveEventArgs args)
{
if (args.Name.StartsWith("SharpSVN"))
{
var fileName = Path.GetFullPath(Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE") + args.Name);
if (File.Exists(fileName))
{
return(System.Reflection.Assembly.LoadFile(fileName));
}
}
return(null);
}
private static Assembly ResolveRhinoCommon(object sender, s.ResolveEventArgs args)
{
var name = args.Name;
if (!name.StartsWith("RhinoCommon"))
{
return(null);
}
var path = s.IO.Path.Combine(systemDir, "RhinoCommon.dll");
return(Assembly.LoadFrom(path));
}
/// Will attempt to load missing assembly from either x86 or x64 subdir
internal static System.Reflection.Assembly Resolver(object sender, System.ResolveEventArgs args)
{
string assembly_name = new AssemblyName(args.Name).Name + ".dll";
string resource_path = "AnyCPU.Resources." + Platform() + "." + assembly_name;
string file_path = GetInteropDLLPath(assembly_name);
using (var dll_resource = System.Reflection.Assembly.GetAssembly(typeof(ModuleInitializer)).GetManifestResourceStream(resource_path))
{
if (dll_resource == null)
{
return(null);
}
if (System.IO.File.Exists(file_path))
{
System.IO.File.Delete(file_path);
}
string directory = System.IO.Path.GetDirectoryName(file_path);
if (!System.IO.Directory.Exists(directory))
{
System.IO.Directory.CreateDirectory(directory);
}
using (System.IO.FileStream file_stream = new FileStream(file_path, FileMode.Create))
{
byte[] byte_array = new byte[(int)dll_resource.Length];
dll_resource.Read(byte_array, 0, (int)dll_resource.Length);
file_stream.Write(byte_array, 0, byte_array.Length);
// Since Managed C++ dlls also contained native code, the assembly must be loaded using a LoadFrom!
//return Assembly.Load(byte_array);
}
}
Assembly assembly = Assembly.LoadFrom(file_path);
// Unable to delete file while the assembly is loaded into the domain.
//File.Delete(file_path);
return(assembly);
}
private static SReflection.Assembly AssemblyResolve(object sender, System.ResolveEventArgs args)
{
// Ignore missing resources
if (args.Name.Contains(".resources"))
{
return(null);
}
// check for assemblies already loaded
foreach (SReflection.Assembly assembly in System.AppDomain.CurrentDomain.GetAssemblies())
{
if (assembly.GetName().Name == args.Name)
{ // We had found it. Let's check for a conflict.
string asmFile = FindThisGuy(args.Name, false);
if (null != asmFile && assembly.Location != asmFile)
{
LOG.error("Found a duplicated Assembly for {0} on file {1}. This is an error, there can be only one! #highlanderFeelings", args.Name, asmFile);
}
return(assembly);
}
}
{
string asmFile = FindThisGuy(args.Name, true);
if (null != asmFile)
{
try
{
LOG.force("Found it on {0}.", asmFile);
//return LoadAssemblyByKsp(args.Name, asmFile);
return(SReflection.Assembly.LoadFrom(asmFile));
}
catch (System.Exception ex)
{
LOG.error("Error {0} loading {1} from {2}!", ex.Message, args.Name, asmFile);
return(null);
}
}
}
return(null);
}
/// <summary>
/// This delegate helps with resolving types and can be used as a eventhandler
/// for a <see cref="System.AppDomain.AssemblyResolve"/> event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The event data with information about the type.</param>
/// <returns>A reference to the assembly where the type is located.</returns>
/// <remarks>
/// Use this handler when reading back types from a serialization stread
/// saved with an earlier version of this assembly.
/// </remarks>
public static Assembly AssemblyResolver(object sender, System.ResolveEventArgs e)
{
if (e.Name.StartsWith(DiagramAssembly.Name))
{
return(DiagramAssembly.Assembly);
}
else
{
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int n = 0; n < assemblies.Length; n++)
{
if (assemblies[n].GetName().Name == e.Name)
{
return(assemblies[n]);
}
}
}
return(null);
}
private static Assembly CurrentDomainOnAssemblyResolve(object sender, System.ResolveEventArgs args) => _AssemblyResolve?.Invoke(sender, args);
/// <summary>
/// Used to resolve assemblies available to the <see cref = "UnitOperationSystem"/>
/// </summary>
/// <remarks>
/// <para>This method resolves the assembly locations for types being created. The priority for locating
/// assemblies is the current applcation domain, then the Cape-Open directory located in the Common Program
/// Files environment directory (typically C:\Program Files\Common Files\Cape-Open).</para>
/// <para></para>
/// </remarks>
/// <param name="sender">The source of the event.</param>
/// <param name="args">Information about the item to be resolved</param>
/// <returns>The assembly that resolves the type, assembly, or resource; or null if the assembly cannot be resolved.</returns>
static public System.Reflection.Assembly MyResolveEventHandler(Object sender, System.ResolveEventArgs args)
{
System.Reflection.Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (System.Reflection.Assembly assembly in assemblies)
{
if (args.Name == assembly.FullName)
{
return(assembly);
}
}
string path = System.Environment.GetFolderPath(Environment.SpecialFolder.CommonProgramFiles) + "\\Cape-Open";
return(SearchPathForAssemblies(path, args.Name));
}
static System.Reflection.Assembly MyResolveEventHandler(Object sender, System.ResolveEventArgs args)
{
return(typeof(CapeObjectBase).Assembly);
}
public Assembly OnExecuting(object sender, System.ResolveEventArgs e)
{
Trace.TraceInformation("Begin " + e.Name);
return(null);
}
private void ResolveEventHandler(object esnder, ResolveEventArgs args)
{
}
public static Assembly ResolveAssembly(object sender, System.ResolveEventArgs args)
{
if (args == null || string.IsNullOrEmpty(args.Name))
{
Kohl.Framework.Logging.Log.Warn("Assembly to be loaded can't be reflected.");
return(null);
}
lock (locker)
{
string[] fields = args.Name.Split(',');
string name = fields[0];
string culture = fields[2];
// failing to ignore queries for satellite resource assemblies or using [assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.MainAssembly)]
// in AssemblyInfo.cs will crash the program on non en-US based system cultures.
if (name.EndsWith(".resources") && !culture.EndsWith("neutral"))
{
return(null);
}
// Serialization assemblies - can be ignored - not yet loaded
if (name == "mscorlib.XmlSerializers" || name == "Terminals.Configuration.XmlSerializers")
{
return(null);
}
/* find all dlls from all directories */
string[] dlls = System.IO.Directory.GetFiles(Kohl.Framework.Info.AssemblyInfo.Directory, "*.dll", System.IO.SearchOption.AllDirectories);
for (int i = 0; i < dlls.Length; i++)
{
try
{
string fileNameWithoutExtension = System.IO.Path.GetFileNameWithoutExtension(dlls[i]);
// Load only the file specified in the function argument - if the filename received from Directory::GetFiles() doesn't match the
// argument check the next dll until we find the one needed to be loaded dynamically
if (fileNameWithoutExtension != args.Name.Split(',')[0])
{
continue;
}
// Load the file into the application's working set
//Assembly asm = Assembly.LoadFile(dlls[i]);
Assembly asm = Assembly.LoadFrom(dlls[i]);
// The dll has been found - return the assembly
if (asm.FullName == args.Name)
{
Kohl.Framework.Logging.Log.Info("Dynamically resolved assembly '" + args.Name + "'.");
return(asm);
}
}
catch (Exception ex)
{
Kohl.Framework.Logging.Log.Error("Error loading " + args.Name, ex);
}
}
string requestingAssembly = args.RequestingAssembly == null ? "-" : args.RequestingAssembly.FullName;
Kohl.Framework.Logging.Log.Debug("Error resolving " + args.Name + ", requesting assembly: " + requestingAssembly);
return(null);
}
}
private System.Reflection.Assembly CurrentDomain_AssemblyResolve(object sender, System.ResolveEventArgs args)
{
return(DependencyResolver.ResolveAssembly(sender, args));
}
// workaround MS.NET bugs with some specific value / generic types hierarchy
private Assembly resolve_hack(object _, System.ResolveEventArgs __)
{
//Message.Debug ($ "resolve_hack: $(args.Name)");
return _assembly_builder;
}
//**************************************************
//* Private
//**************************************************
//-------------------------------------------------
/// <summary>
/// Custom assembly resolve implementation that
/// recognizes requests for 'p4dn' assemblies.
/// </summary>
private static Assembly CustomResolve(object sender, System.ResolveEventArgs args)
{
const string p4DnName = "p4dn";
if (null != args && null != args.Name && args.Name.StartsWith(p4DnName, StringComparison.OrdinalIgnoreCase))
{
if (null == Bootstrapper._p4DnAssembly) // CLR guarantees proper access to volatile reference by multiple threads
{
lock (Bootstrapper.Sync)
{
if (null == Bootstrapper._p4DnAssembly) // just to be sure, recheck the assembly reference after the memory barrier issued by the lock above
{
// determine target assembly name
var targetDirectory = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
Path.Combine(
"Perforce",
"P4.NET"));
var architecture = (IntPtr.Size == 4 ? "x86" : "x64").ToLowerInvariant();
var thisAssembly = typeof(Bootstrapper).Assembly;
var thisAssemblyFileVersion = FileVersionInfo.GetVersionInfo(thisAssembly.Location).FileVersion;
var targetFileName = Path.Combine(
targetDirectory,
string.Concat(
ClrSpec,
".",
BuildSpec,
".",
thisAssemblyFileVersion,
".",
architecture,
".",
p4DnName,
".dll"));
// if needed (target file does not exist or older than this assembly),
// extract embedded resources to target directory now
var targetFileInfo = new FileInfo(targetFileName);
if (!targetFileInfo.Exists)
{
if (!Directory.Exists(targetDirectory))
{
Directory.CreateDirectory(targetDirectory);
}
const int bufferSize = 0x10000; // 64k
var buffer = new byte[bufferSize];
foreach (var resourceName in thisAssembly.GetManifestResourceNames())
{
const string bootstrapperPrefix = @"P4API.Bootstrapper.";
if (resourceName.StartsWith(bootstrapperPrefix, StringComparison.OrdinalIgnoreCase))
{
var extractName = Path.Combine(
targetDirectory,
resourceName
.Substring(bootstrapperPrefix.Length)
.Replace(@"framework", ClrSpec)
.Replace(@"build", BuildSpec)
.Replace(@"version", thisAssemblyFileVersion));
using (var readStream = thisAssembly.GetManifestResourceStream(resourceName))
{
if (null == readStream)
{
throw new InvalidOperationException("Unable to GetManifestResourceStream for one of Assembly.GetManifestResourceNames values");
}
using (var writeStream = File.Create(extractName, bufferSize))
{
int read;
while (0 != (read = readStream.Read(buffer, 0, bufferSize)))
{
writeStream.Write(buffer, 0, read);
}
}
}
}
}
}
// load the target file as assembly
Bootstrapper._p4DnAssembly = Assembly.LoadFile(targetFileName);
}
}
}
// make sure we can satisfy the requested reference with the embedded assembly (now extracted)
var reference = new AssemblyName(args.Name);
if (AssemblyName.ReferenceMatchesDefinition(reference, Bootstrapper._p4DnAssembly.GetName()))
{
return(Bootstrapper._p4DnAssembly);
}
}
// we don't recognize the requested reference
return(null);
}