ฉันจะระบุพา ธ [DllImport] ที่รันไทม์ได้อย่างไร

ในความเป็นจริงฉันมี C ++ (ทำงาน) DLL ที่ฉันต้องการนำเข้าสู่โปรเจ็กต์ C # ของฉันเพื่อเรียกใช้ฟังก์ชั่น

มันจะทำงานเมื่อฉันระบุเส้นทางแบบเต็มไปยัง DLL เช่นนี้

string str = "C:\\Users\\userName\\AppData\\Local\\myLibFolder\\myDLL.dll";
[DllImport(str, CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

ปัญหาคือมันจะเป็นโครงการที่ติดตั้งได้ดังนั้นโฟลเดอร์ของผู้ใช้จะไม่เหมือนเดิม (เช่น: pierre, paul, jack, mum, dad, ... ) ขึ้นอยู่กับคอมพิวเตอร์ / เซสชันที่ต้องการเปิดใช้งาน

ดังนั้นฉันต้องการรหัสของฉันจะเป็นทั่วไปเล็กน้อยเช่นนี้

/* 
goes right to the temp folder of the user 
    "C:\\Users\\userName\\AppData\\Local\\temp"
then go to parent folder
    "C:\\Users\\userName\\AppData\\Local"
and finally go to the DLL's folder
    "C:\\Users\\userName\\AppData\\Local\\temp\\myLibFolder"
*/

string str = Path.GetTempPath() + "..\\myLibFolder\\myDLL.dll"; 
[DllImport(str, CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

เรื่องใหญ่ก็คือ "DllImport" ต้องการพารามิเตอร์ "สตริงสตริง" สำหรับไดเรกทอรีของ DLL

ดังนั้นคำถามของฉันคือ :: สิ่งที่สามารถทำได้ในกรณีนี้?

ตรงกันข้ามกับคำแนะนำโดยคำตอบอื่น ๆ การใช้DllImportคุณลักษณะยังคงเป็นวิธีที่ถูกต้อง

ฉันไม่เข้าใจว่าทำไมคุณไม่สามารถทำเหมือนคนอื่นในโลกและระบุเส้นทางที่สัมพันธ์กับ DLL ของคุณ ใช่เส้นทางที่ติดตั้งแอปพลิเคชันของคุณจะแตกต่างกันไปในคอมพิวเตอร์ของคนอื่น แต่โดยทั่วไปก็เป็นกฎสากลเมื่อนำมาปรับใช้ DllImportกลไกการออกแบบที่มีในใจ

ในความเป็นจริงมันไม่ได้แม้แต่จะDllImportจัดการกับมัน มันเป็นกฎการโหลด Win32 DLL แบบดั้งเดิมที่ควบคุมสิ่งต่างๆโดยไม่คำนึงว่าคุณกำลังใช้ wrappers ที่มีการจัดการที่มีประโยชน์หรือไม่ (P / Invoke marshaller เพิ่งเรียกLoadLibrary) กฎเหล่านั้นมีรายละเอียดมากมายที่นี่แต่สิ่งสำคัญถูกคัดลอกมาที่นี่:

ก่อนที่ระบบจะค้นหา DLL จะตรวจสอบสิ่งต่อไปนี้:

• ถ้า DLL ที่มีชื่อโมดูลเดียวกันถูกโหลดในหน่วยความจำแล้วระบบจะใช้ DLL ที่โหลดแล้วไม่ว่าจะเป็นไดเรกทอรีใดระบบจะไม่ค้นหา DLL
• หาก DLL อยู่ในรายการ DLLs ที่รู้จักสำหรับรุ่นของ Windows ที่แอปพลิเคชันทำงานอยู่ระบบจะใช้สำเนา DLL ที่รู้จัก (และ DLL ที่ขึ้นกับ DLL ที่รู้จักถ้ามี) ระบบไม่ค้นหา DLL

---

หากSafeDllSearchModeเปิดใช้งาน (ค่าเริ่มต้น) ลำดับการค้นหาจะเป็นดังนี้:

1. ไดเรกทอรีที่โหลดแอปพลิเคชัน
2. ไดเรกทอรีระบบ ใช้GetSystemDirectoryฟังก์ชั่นเพื่อรับเส้นทางของไดเรกทอรีนี้
3. ไดเรกทอรีระบบ 16 บิต ไม่มีฟังก์ชั่นที่ได้รับเส้นทางของไดเรกทอรีนี้ แต่มันถูกค้นหา
4. ไดเรกทอรี Windows ใช้GetWindowsDirectoryฟังก์ชั่นเพื่อรับเส้นทางของไดเรกทอรีนี้
5. ไดเรกทอรีปัจจุบัน
6. ไดเรกทอรีที่ระบุไว้ในPATHตัวแปรสภาพแวดล้อม โปรดทราบว่านี่ไม่รวมเส้นทางต่อแอปพลิเคชันที่ระบุโดยคีย์รีจิสทรีของ App Paths ไม่มีการใช้คีย์ App Paths เมื่อคำนวณเส้นทางการค้นหา DLL

ดังนั้นหากคุณตั้งชื่อ DLL ของคุณเหมือนกับระบบ DLL (ซึ่งคุณไม่ควรทำอย่างชัดเจนไม่ว่าในกรณีใด ๆ ) ลำดับการค้นหาเริ่มต้นจะเริ่มค้นหาในไดเรกทอรีที่โหลดแอปพลิเคชันของคุณ หากคุณวาง DLL ไว้ในระหว่างการติดตั้งจะพบได้ ปัญหาที่ซับซ้อนทั้งหมดหายไปหากคุณใช้เส้นทางที่สัมพันธ์กัน

แค่เขียน:

[DllImport("MyAppDll.dll")] // relative path; just give the DLL's name
static extern bool MyGreatFunction(int myFirstParam, int mySecondParam);

แต่ถ้าวิธีนี้ใช้ไม่ได้ไม่ว่าด้วยเหตุผลใดและคุณต้องบังคับให้แอปพลิเคชันค้นหาไดเรกทอรีอื่นสำหรับ DLL คุณสามารถปรับเปลี่ยนเส้นทางการค้นหาเริ่มต้นโดยใช้SetDllDirectoryฟังก์ชันได้
โปรดทราบว่าตามเอกสาร:

หลังจากเรียกSetDllDirectoryเส้นทางการค้นหา DLL มาตรฐานคือ:

1. ไดเรกทอรีที่โหลดแอปพลิเคชัน
2. ไดเรกทอรีที่ระบุโดยlpPathNameพารามิเตอร์
3. ไดเรกทอรีระบบ ใช้GetSystemDirectoryฟังก์ชั่นเพื่อรับเส้นทางของไดเรกทอรีนี้
4. ไดเรกทอรีระบบ 16 บิต ไม่มีฟังก์ชั่นที่ได้รับเส้นทางของไดเรกทอรีนี้ แต่มันถูกค้นหา
5. ไดเรกทอรี Windows ใช้GetWindowsDirectoryฟังก์ชั่นเพื่อรับเส้นทางของไดเรกทอรีนี้
6. ไดเรกทอรีที่ระบุไว้ในPATHตัวแปรสภาพแวดล้อม

ดังนั้นตราบใดที่คุณเรียกใช้ฟังก์ชันนี้ก่อนที่คุณจะเรียกใช้ฟังก์ชันที่นำเข้าจาก DLL เป็นครั้งแรกคุณสามารถปรับเปลี่ยนเส้นทางการค้นหาเริ่มต้นที่ใช้เพื่อค้นหา DLLs ประโยชน์ที่ได้รับแน่นอนคือคุณสามารถส่งผ่านค่าไดนามิกไปยังฟังก์ชันนี้ซึ่งคำนวณได้ในขณะใช้งาน ไม่สามารถใช้DllImportแอตทริบิวต์ได้ดังนั้นคุณจะยังคงใช้พา ธ สัมพัทธ์ (ชื่อของ DLL เท่านั้น) ที่นั่นและพึ่งพาลำดับการค้นหาใหม่เพื่อค้นหาให้คุณ

คุณจะต้อง P / เรียกใช้ฟังก์ชันนี้ การประกาศมีลักษณะดังนี้:

[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
static extern bool SetDllDirectory(string lpPathName);

ดียิ่งกว่าข้อเสนอแนะของ Ran ในการใช้GetProcAddressงานเพียงโทรไปยังLoadLibraryก่อนที่จะโทรไปยังDllImportฟังก์ชั่นใด ๆ(มีเพียงชื่อไฟล์ที่ไม่มีเส้นทาง) และพวกเขาจะใช้โมดูลที่โหลดโดยอัตโนมัติ

ฉันใช้วิธีนี้เพื่อเลือกรันไทม์ไม่ว่าจะโหลด DLL เนทิฟ 32- บิตหรือ 64- บิตโดยไม่ต้องแก้ไขฟังก์ชั่น P / Invoke-d ติดรหัสโหลดในตัวสร้างสแตติกสำหรับประเภทที่มีฟังก์ชั่นที่นำเข้าและมันจะทำงานได้ดี

หากคุณต้องการไฟล์. dll ที่ไม่ได้อยู่ในพา ธ หรือที่ตั้งของแอปพลิเคชันฉันไม่คิดว่าคุณจะทำได้เพราะDllImportเป็นแอททริบิวต์และแอททริบิวเป็นเมทาดาทาที่ตั้งค่าตามประเภทสมาชิกและอื่น ๆ องค์ประกอบทางภาษา

อีกทางเลือกหนึ่งที่สามารถช่วยให้คุณบรรลุสิ่งที่ฉันคิดว่าคุณพยายามคือใช้ Native LoadLibraryผ่าน P / Invoke เพื่อโหลด. dll จากพา ธ ที่คุณต้องการจากนั้นใช้GetProcAddressเพื่อรับการอ้างอิงถึงฟังก์ชันที่คุณต้องการ จาก. dll จากนั้นใช้สิ่งเหล่านี้เพื่อสร้างผู้รับมอบสิทธิ์ที่คุณสามารถเรียกใช้

เพื่อให้ง่ายต่อการใช้งานคุณสามารถตั้งค่าผู้รับมอบสิทธิ์นี้เป็นเขตข้อมูลในชั้นเรียนของคุณเพื่อให้ดูเหมือนเป็นวิธีการเรียกสมาชิก

แก้ไข

นี่คือข้อมูลโค้ดที่ใช้งานได้และแสดงสิ่งที่ฉันหมายถึง

class Program
{
    static void Main(string[] args)
    {
        var a = new MyClass();
        var result = a.ShowMessage();
    }
}

class FunctionLoader
{
    [DllImport("Kernel32.dll")]
    private static extern IntPtr LoadLibrary(string path);

    [DllImport("Kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

    public static Delegate LoadFunction<T>(string dllPath, string functionName)
    {
        var hModule = LoadLibrary(dllPath);
        var functionAddress = GetProcAddress(hModule, functionName);
        return Marshal.GetDelegateForFunctionPointer(functionAddress, typeof (T));
    }
}

public class MyClass
{
    static MyClass()
    {
        // Load functions and set them up as delegates
        // This is just an example - you could load the .dll from any path,
        // and you could even determine the file location at runtime.
        MessageBox = (MessageBoxDelegate) 
            FunctionLoader.LoadFunction<MessageBoxDelegate>(
                @"c:\windows\system32\user32.dll", "MessageBoxA");
    }

    private delegate int MessageBoxDelegate(
        IntPtr hwnd, string title, string message, int buttons); 

    /// <summary>
    /// This is the dynamic P/Invoke alternative
    /// </summary>
    static private MessageBoxDelegate MessageBox;

    /// <summary>
    /// Example for a method that uses the "dynamic P/Invoke"
    /// </summary>
    public int ShowMessage()
    {
        // 3 means "yes/no/cancel" buttons, just to show that it works...
        return MessageBox(IntPtr.Zero, "Hello world", "Loaded dynamically", 3);
    }
}

หมายเหตุ: ฉันไม่ได้รำคาญที่จะใช้FreeLibraryดังนั้นรหัสนี้ไม่สมบูรณ์ ในแอปพลิเคชันจริงคุณควรระมัดระวังที่จะปล่อยโมดูลที่โหลดเพื่อหลีกเลี่ยงการรั่วไหลของหน่วยความจำ

ตราบใดที่คุณรู้ไดเรกทอรีที่สามารถหาไลบรารี C ++ ของคุณได้ในขณะใช้งานมันน่าจะง่าย ฉันเห็นได้ชัดว่านี่เป็นกรณีในรหัสของคุณ คุณmyDll.dllจะอยู่ในmyLibFolderไดเรกทอรีภายในโฟลเดอร์ชั่วคราวของผู้ใช้ปัจจุบัน

string str = Path.GetTempPath() + "..\\myLibFolder\\myDLL.dll"; 

ตอนนี้คุณสามารถใช้คำสั่ง DllImport ต่อไปโดยใช้สตริง const ดังที่แสดงด้านล่าง:

[DllImport("myDLL.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

เมื่อถึงรันไทม์ก่อนที่คุณจะเรียกใช้DLLFunctionฟังก์ชัน (มีอยู่ในไลบรารี C ++) ให้เพิ่มโค้ดบรรทัดนี้ในโค้ด C #:

string assemblyProbeDirectory = Path.GetTempPath() + "..\\myLibFolder\\myDLL.dll"; 
Directory.SetCurrentDirectory(assemblyProbeDirectory);

เพียงแค่สั่งให้ CLR ค้นหาไลบรารี C ++ ที่ไม่มีการจัดการที่เส้นทางไดเรกทอรีที่คุณได้รับในขณะใช้งานโปรแกรมของคุณ Directory.SetCurrentDirectoryเรียกชุดไดเรกทอรีการทำงานปัจจุบันของแอปพลิเคชันไปยังไดเรกทอรีที่ระบุ หากคุณmyDLL.dllอยู่ที่เส้นทางที่แสดงโดยassemblyProbeDirectoryเส้นทางก็จะได้รับการโหลดและฟังก์ชั่นที่ต้องการจะได้รับการเรียกผ่าน p / วิงวอน

กำหนดเส้นทาง dll ในไฟล์กำหนดค่า

<add key="dllPath" value="C:\Users\UserName\YourApp\myLibFolder\myDLL.dll" />

ก่อนที่จะเรียก dll ในแอพของคุณให้ทำดังต่อไปนี้

string dllPath= ConfigurationManager.AppSettings["dllPath"];    
   string appDirectory = Path.GetDirectoryName(dllPath);
   Directory.SetCurrentDirectory(appDirectory);

จากนั้นเรียก dll และคุณสามารถใช้เช่นด้านล่าง

 [DllImport("myDLL.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int DLLFunction(int Number1, int Number2);

DllImport จะทำงานได้ดีโดยไม่ระบุเส้นทางที่สมบูรณ์ตราบใดที่ dll ตั้งอยู่ที่ใดที่หนึ่งบนเส้นทางของระบบ คุณอาจจะสามารถเพิ่มโฟลเดอร์ของผู้ใช้ลงในพา ธ ชั่วคราว

หากทุกอย่างล้มเหลวเพียงแค่ใส่ DLL ในwindows\system32โฟลเดอร์ คอมไพเลอร์จะพบมัน ระบุ DLL ที่จะโหลดจากด้วย: DllImport("user32.dll"...ตั้งค่า EntryPoint = "my_unmanaged_function"เพื่อนำเข้าฟังก์ชั่นที่ไม่มีการจัดการที่คุณต้องการไปยังแอป C # ของคุณ:

 using System;
using System.Runtime.InteropServices;

class Example
{
   // Use DllImport to import the Win32 MessageBox function.

   [DllImport ("user32.dll", CharSet = CharSet.Auto)]
   public static extern int MessageBox 
      (IntPtr hWnd, String text, String caption, uint type);

   static void Main()
   {
      // Call the MessageBox function using platform invoke.
      MessageBox (new IntPtr(0), "Hello, World!", "Hello Dialog", 0);    
   }
}

แหล่งที่มาและDllImportตัวอย่างเพิ่มเติม: http://msdn.microsoft.com/en-us/library/aa288468(v=vs.71).aspx