/// <summary> /// Get's the current process architecture while keeping track of any assumptions or possible errors. /// </summary> /// <returns></returns> private ProcessArchitectureInfo GetProcessArchitecture() { ProcessArchitectureInfo processInfo = new ProcessArchitectureInfo(); // BUGBUG: Will this always be reliable? string processArchitecture = Environment.GetEnvironmentVariable(PROCESSOR_ARCHITECTURE); if (!String.IsNullOrEmpty(processArchitecture)) { // Sanity check processInfo.Architecture = processArchitecture; } else { processInfo.Architecture = "x86"; processInfo.Warnings.Add("Failed to detect processor architecture, falling back to x86."); } var addressWidth = processorArchitectureAddressWidthPlatforms[processInfo.Architecture]; if (addressWidth != IntPtr.Size) { processInfo.Warnings.Add(String.Format("Expected the detected processing architecture of {0} to have an address width of {1} Bytes but was {2} Bytes.", processInfo.Architecture, addressWidth, IntPtr.Size)); } return(processInfo); }
private IntPtr LoadLibraryInternal(string dllName, string baseDirectory, ProcessArchitectureInfo processArchInfo) { var platformName = GetPlatformName(processArchInfo.Architecture); var expectedDllDirectory = Path.Combine( Path.Combine(baseDirectory, DllDirectory), platformName); return(this.LoadLibraryRaw(dllName, expectedDllDirectory)); }
private IntPtr LoadLibraryRaw(string dllName, string baseDirectory) { var libraryHandle = IntPtr.Zero; var fileName = FixUpDllFileName(Path.Combine(baseDirectory, dllName)); #if WINRT && false // MP! Note: This is a hack, needs refinement. We don't need to carry payload of both binaries for WinRT because the appx is platform specific. ProcessArchitectureInfo processInfo = GetProcessArchitecture(); string cpu = "x86"; if (processInfo.Architecture == "AMD64") { cpu = "x64"; } string dllpath = baseDirectory.Replace($"dll\\{cpu}", ""); fileName = $"{dllpath}{dllName}.dll"; // Show where we're trying to load the file from Debug.WriteLine($"Trying to load native library \"{fileName}\"..."); #endif if (File.Exists(fileName)) { // Attempt to load dll try { libraryHandle = Win32Api.LoadLibrary(fileName); if (libraryHandle != IntPtr.Zero) { // library has been loaded Debug.WriteLine($"Successfully loaded native library \"{fileName}\"."); loadedAssemblies.Add(dllName); } else { Debug.WriteLine($"Failed to load native library \"{fileName}\".\r\nCheck windows event log."); } } catch (Exception e) { // ReSharper disable once RedundantAssignment var lastError = Marshal.GetLastWin32Error(); Debug.WriteLine( $"Failed to load native library \"{fileName}\".\r\nLast Error:{lastError}\r\nCheck inner exception and\\or windows event log.\r\nInner Exception: {e}"); } } else { Debug.WriteLine(string.Format(CultureInfo.CurrentCulture, "The native library \"{0}\" does not exist.", fileName)); } return(libraryHandle); }
private IntPtr LoadLibraryInternal(string dllName, string baseDirectory, ProcessArchitectureInfo processArchInfo) { //IntPtr libraryHandle = IntPtr.Zero; var platformName = GetPlatformName(processArchInfo.Architecture); var expectedDllDirectory = Path.Combine( Path.Combine(baseDirectory, DllDirectory), platformName); //var fileName = FixUpDllFileName(Path.Combine(expectedDllDirectory, dllName)); return(LoadLibraryRaw(dllName, expectedDllDirectory)); }
private IntPtr LoadLibraryInternal(string dllName, string baseDirectory, ProcessArchitectureInfo processArchInfo) { IntPtr libraryHandle = IntPtr.Zero; var platformName = GetPlatformName(processArchInfo.Architecture); var expectedDllDirectory = Path.Combine( Path.Combine(baseDirectory, DllDirectory), platformName); var fileName = FixUpDllFileName(Path.Combine(expectedDllDirectory, dllName)); if (File.Exists(fileName)) { // Attempt to load dll try { // Show where we're trying to load the file from Trace.TraceInformation(String.Format(CultureInfo.CurrentCulture, "Trying to load native library \"{0}\"...", fileName)); libraryHandle = Win32LoadLibrary(fileName); if (libraryHandle != IntPtr.Zero) { // library has been loaded Trace.TraceInformation(String.Format(CultureInfo.CurrentCulture, "Successfully loaded native library \"{0}\".", fileName)); loadedAssemblies.Add(dllName); } else { Trace.TraceError( "Failed to load native library \"{0}\".\r\nCheck windows event log.", fileName); } } catch (Exception e) { var lastError = Marshal.GetLastWin32Error(); Trace.TraceError( "Failed to load native library \"{0}\".\r\nLast Error:{1}\r\nCheck inner exception and\\or windows event log.\r\nInner Exception: {2}", fileName, lastError, e); } } else { Trace.TraceWarning(String.Format(CultureInfo.CurrentCulture, "The native library \"{0}\" does not exist.", fileName)); } return(libraryHandle); }
/// <summary> /// Get's the current process architecture while keeping track of any assumptions or possible errors. /// </summary> /// <returns></returns> private ProcessArchitectureInfo GetProcessArchitecture() { // BUGBUG: Will this always be reliable? var processArchitecture = Environment.GetEnvironmentVariable(ProcessorArchitecture); var processInfo = new ProcessArchitectureInfo(); if (!string.IsNullOrEmpty(processArchitecture)) { // Sanity check processInfo.Architecture = processArchitecture; } else { processInfo.AddWarning("Failed to detect processor architecture, falling back to x86."); processInfo.Architecture = (IntPtr.Size == 8) ? "x64" : "x86"; } var addressWidth = processorArchitectureAddressWidthPlatforms[processInfo.Architecture]; if (addressWidth != IntPtr.Size) { if (string.Equals(processInfo.Architecture, "AMD64", StringComparison.OrdinalIgnoreCase) && IntPtr.Size == 4) { // fall back to x86 if detected x64 but has an address width of 32 bits. processInfo.Architecture = "x86"; processInfo.AddWarning( "Expected the detected processing architecture of {0} to have an address width of {1} Bytes but was {2} Bytes, falling back to x86.", processInfo.Architecture, addressWidth, IntPtr.Size); } else { // no fallback possible processInfo.AddWarning( "Expected the detected processing architecture of {0} to have an address width of {1} Bytes but was {2} Bytes.", processInfo.Architecture, addressWidth, IntPtr.Size); } } return(processInfo); }
private IntPtr LoadLibraryInternal(string dllName, string baseDirectory, ProcessArchitectureInfo processArchInfo) { //IntPtr libraryHandle = IntPtr.Zero; var platformName = GetPlatformName(processArchInfo.Architecture); var expectedDllDirectory = Path.Combine( Path.Combine(baseDirectory, DllDirectory), platformName); //var fileName = FixUpDllFileName(Path.Combine(expectedDllDirectory, dllName)); return LoadLibraryRaw(dllName, expectedDllDirectory); }
/// <summary> /// Get's the current process architecture while keeping track of any assumptions or possible errors. /// </summary> /// <returns></returns> private ProcessArchitectureInfo GetProcessArchitecture() { // BUGBUG: Will this always be reliable? string processArchitecture = Environment.GetEnvironmentVariable(ProcessorArchitecture); var processInfo = new ProcessArchitectureInfo(); if (!String.IsNullOrEmpty(processArchitecture)) { // Sanity check processInfo.Architecture = processArchitecture; } else { processInfo.AddWarning("Failed to detect processor architecture, falling back to x86."); processInfo.Architecture = (IntPtr.Size == 8) ? "x64" : "x86"; } var addressWidth = processorArchitectureAddressWidthPlatforms[processInfo.Architecture]; if (addressWidth != IntPtr.Size) { if (String.Equals(processInfo.Architecture, "AMD64", StringComparison.OrdinalIgnoreCase) && IntPtr.Size == 4) { // fall back to x86 if detected x64 but has an address width of 32 bits. processInfo.Architecture = "x86"; processInfo.AddWarning("Expected the detected processing architecture of {0} to have an address width of {1} Bytes but was {2} Bytes, falling back to x86.", processInfo.Architecture, addressWidth, IntPtr.Size); } else { // no fallback possible processInfo.AddWarning("Expected the detected processing architecture of {0} to have an address width of {1} Bytes but was {2} Bytes.", processInfo.Architecture, addressWidth, IntPtr.Size); } } return processInfo; }
private IntPtr LoadLibraryInternal(string dllName, string baseDirectory, ProcessArchitectureInfo processArchInfo) { IntPtr libraryHandle = IntPtr.Zero; var platformName = GetPlatformName(processArchInfo.Architecture); var expectedDllDirectory = Path.Combine( Path.Combine(baseDirectory, DllDirectory), platformName); var fileName = FixUpDllFileName(Path.Combine(expectedDllDirectory, dllName)); if (File.Exists(fileName)) { // Attempt to load dll try { // Show where we're trying to load the file from Trace.TraceInformation(String.Format(CultureInfo.CurrentCulture, "Trying to load native library \"{0}\"...", fileName)); libraryHandle = Win32LoadLibrary(fileName); if (libraryHandle != IntPtr.Zero) { // library has been loaded Trace.TraceInformation(String.Format(CultureInfo.CurrentCulture, "Successfully loaded native library \"{0}\".", fileName)); loadedAssemblies.Add(dllName); } else { Trace.TraceError( "Failed to load native library \"{0}\".\r\nCheck windows event log.", fileName); } } catch (Exception e) { var lastError = Marshal.GetLastWin32Error(); Trace.TraceError( "Failed to load native library \"{0}\".\r\nLast Error:{1}\r\nCheck inner exception and\\or windows event log.\r\nInner Exception: {2}", fileName, lastError, e); } } else { Trace.TraceWarning(String.Format(CultureInfo.CurrentCulture, "The native library \"{0}\" does not exist.", fileName)); } return libraryHandle; }