loadlibrary

Up until now, I had some sort of plugin mechanism in which I loaded dlls using LoadLibrary and GetProcAddress to create a concrete object and return a common interface. This worked fine until I decided that one of the dlls should be an exe. LoadLibrary's documentation says that it can be used for exe's as well, so I gave it a shot. The exe gets loaded without errors, as GetProcAddress. But when I try to call my concrete object's constructor, I get an access violation. I thought this would happen because loading an exe does not load all the dlls it uses. So I tried loading them using

If I use the Win32 API LoadLibrary to load the same DLL 3 times in a row it should return 3 distinct handles and the functions in each library should all have different addresses correct? (Or does it do something "smart" and detect if the dll has already been loaded for the process and just point to the same module?) It does something smart. Windows keeps a reference count for each DLL loaded through LoadLibrary. That's why you have to call FreeLibrary once for each corresponding LoadLibrary call. Assuming you don't free the DLL first, each call to LoadLibrary will give you the same handle.

I have a managed C++ assembly I'm loading dynamically in an unmanaged c++ application through a standard LoadLibrary() call. The managed C++ assembly has dependencies on several more managed (C#) assemblies. Everything worked fine until I moved all the managed assemblies to a subdirectory of the unmananged application. To illustrate: Managed C++ .dll (MyCoolDll.dll) Dependent on DotNetDll1.dll Dependent on DotNetDll2.dll Unmanaged C++ app (MyCoolApp.exe) Loads MyCoolDll.dll via LoadLibrary("MyCoolDll.dll") This worked fine, until I moved MyCoolDll.dll, DotNetDll1.dll & DotNetDll2.dll to

I have external .DLL file with fast assembler code inside. What is the best way to call functions in this .DLL file to get best performance? Your DLL might be in python or c++, whatever , do the same as follow. This is your DLL file in C++. header: extern "C" __declspec(dllexport) int MultiplyByTen(int numberToMultiply); Source code file #include "DynamicDLLToCall.h" int MultiplyByTen(int numberToMultiply) { int returnValue = numberToMultiply * 10; return returnValue; } Take a look at the following C# code: static class NativeMethods { [DllImport("kernel32.dll")] public static extern IntPtr

MSDN says: It must not call the LoadLibrary or LoadLibraryEx function (or a function that calls these functions), because this may create dependency loops in the DLL load order. This can result in a DLL being used before the system has executed its initialization code. I tried to call LoadLibrary from DllMain and nothing happened. The only issue that I see is that loaded DLL will use functions in my DLL before rest of my DllMain executes. Why I must not call LoadLibrary in DllMain? EDIT: OK, I realized that I must not call LoadLibrary in DllMain just because I must believe MSDN as other

I want to load my own native libraries in my java application. Those native libraries depend upon third-party libraries (which may or may not be present when my application is installed on the client computer). Inside my java application, I ask the user to specify the location of dependent libs. Once I have this information, I am using it to update the "LD_LIBRARY_PATH" environment variable using JNI code. The following is the code snippet that I am using to change the "LD_LIBRARY_PATH" environment variable. Java code public static final int setEnv(String key, String value) { if (key == null)