ในWindows APIไฟล์ DLL จะถูกจัดระเบียบเป็นส่วนต่างๆแต่ละส่วนจะมีคุณลักษณะเฉพาะของตนเอง เช่น สามารถเขียนได้หรืออ่านได้อย่างเดียว สามารถเรียกใช้งานได้ (สำหรับโค้ด) หรือไม่สามารถเรียกใช้งานได้ (สำหรับข้อมูล) เป็นต้น

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

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

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

เช่นเดียวกับไลบรารีแบบสแตติก ไลบรารีสำหรับนำเข้า DLL จะระบุด้วย.libนามสกุลไฟล์ ตัวอย่างเช่นkernel32.dllซึ่งเป็นไลบรารีแบบไดนามิกหลักสำหรับฟังก์ชันพื้นฐานของ Windows เช่น การสร้างไฟล์และการจัดการหน่วยความจำ จะถูกเชื่อมโยงผ่านkernel32.lib.dll วิธีปกติในการแยกแยะไลบรารีสำหรับนำเข้าจากไลบรารีแบบสแตติกที่ถูกต้องคือการดูขนาด: ไลบรารีสำหรับนำเข้าจะมีขนาดเล็กกว่ามาก เนื่องจากมีเพียงสัญลักษณ์ที่อ้างอิงถึง DLL จริง ซึ่งจะถูกประมวลผลในระหว่างการเชื่อมโยง อย่างไรก็ตาม ทั้งสองประเภทเป็นไฟล์รูปแบบ Unix .ar เหมือนกัน

การเชื่อมโยงไปยังไลบรารีแบบไดนามิกมักจะจัดการโดยการเชื่อมโยงไปยังไลบรารีนำเข้าเมื่อสร้างหรือเชื่อมโยงเพื่อสร้างไฟล์ปฏิบัติการ ไฟล์ปฏิบัติการที่สร้างขึ้นจะมีตารางที่อยู่การนำเข้า (IAT) ซึ่งใช้อ้างอิงการเรียกใช้ฟังก์ชัน DLL ทั้งหมด (แต่ละฟังก์ชัน DLL ที่อ้างอิงจะมีรายการของตัวเองใน IAT) ในระหว่างการทำงาน IAT จะถูกเติมด้วยที่อยู่ที่เหมาะสมซึ่งชี้ไปยังฟังก์ชันใน DLL ที่โหลดแยกต่างหากโดยตรง^{[ 3 ]}

ใน Cygwin/MSYS และ MinGW ไลบรารีนำเข้ามักจะได้รับคำต่อท้าย โดย.dll.aรวมทั้งคำต่อท้าย DLL ของ Windows และคำต่อท้าย ar ของ Unix รูปแบบไฟล์คล้ายกัน แต่สัญลักษณ์ที่ใช้ในการทำเครื่องหมายการนำเข้าจะแตกต่างกัน ( _head_foo_dllเทียบกับ__IMPORT_DESCRIPTOR_foo) ^{[ 4 ]}แม้ว่า ชุดเครื่องมือ GNU Binutilsจะสามารถสร้างไลบรารีนำเข้าและเชื่อมโยงไปยังไลบรารีเหล่านั้นได้ แต่การเชื่อมโยงไปยัง DLL โดยตรงนั้นเร็วกว่า^{[ 5 ]}เครื่องมือทดลองใน MinGW ที่เรียกว่า genlib สามารถใช้เพื่อสร้างไลบรารีนำเข้าด้วยสัญลักษณ์แบบ MSVC ได้

แต่ละฟังก์ชันที่ส่งออกโดย DLL จะถูกระบุด้วยลำดับตัวเลขและอาจมีชื่อด้วย ในทำนองเดียวกัน ฟังก์ชันสามารถนำเข้าจาก DLL ได้ทั้งโดยลำดับหรือโดยชื่อ ลำดับแสดงถึงตำแหน่งของตัวชี้แอดเดรสของฟังก์ชันในตารางแอดเดรสการส่งออกของ DLL โดยทั่วไปแล้ว ฟังก์ชันภายในจะถูกส่งออกโดยใช้ลำดับเท่านั้น สำหรับฟังก์ชัน Windows API ส่วนใหญ่ เฉพาะชื่อเท่านั้นที่จะถูกเก็บรักษาไว้ใน Windows เวอร์ชันต่างๆ ลำดับอาจเปลี่ยนแปลงได้ ดังนั้นจึงไม่สามารถนำเข้าฟังก์ชัน Windows API โดยใช้ลำดับได้อย่างน่าเชื่อถือ

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

นอกจากนี้ยังสามารถผูกไฟล์ปฏิบัติการเข้ากับ DLL เวอร์ชันเฉพาะได้ กล่าวคือ สามารถระบุที่อยู่ของฟังก์ชันที่นำเข้าได้ในระหว่างการคอมไพล์ สำหรับการผูกการนำเข้า ตัวเชื่อมโยงจะบันทึกเวลาและค่าตรวจสอบของ DLL ที่นำเข้าไว้ ในระหว่างการทำงาน Windows จะตรวจสอบว่ามีการใช้ไลบรารีเวอร์ชันเดียวกันหรือไม่ ถ้าใช่ Windows จะข้ามการประมวลผลการนำเข้าไป แต่ถ้าไลบรารีที่ใช้แตกต่างจากที่ผูกไว้ Windows จะประมวลผลการนำเข้าตามปกติ

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

ไฟล์ DLL อาจถูกโหลดอย่างชัดเจนในระหว่างการทำงาน ซึ่งกระบวนการนี้Microsoft เรียกว่า การเชื่อมโยงแบบไดนามิกในระหว่างการทำงาน (run-time dynamic linkingLoadLibrary ) โดยใช้ฟังก์ชัน API (หรือLoadLibraryEx) GetProcAddressฟังก์ชัน API นี้ใช้ในการค้นหาสัญลักษณ์ที่ส่งออกตามชื่อ และFreeLibrary– ใช้ในการยกเลิกการโหลด DLL ฟังก์ชันเหล่านี้คล้ายคลึงกับdlopen, dlsym, และdlcloseในAPI มาตรฐานPOSIX

ขั้นตอนการเชื่อมโยงรันไทม์แบบชัดเจนนั้นเหมือนกันในทุกภาษาที่รองรับตัวชี้ไปยังฟังก์ชันเนื่องจากขึ้นอยู่กับAPI ของ Windowsไม่ใช่โครงสร้างของภาษา

โดยปกติแล้ว แอปพลิเคชันที่เชื่อมโยงกับไลบรารีนำเข้าของ DLL จะไม่สามารถเริ่มต้นได้หากไม่พบ DLL เนื่องจาก Windows จะไม่เรียกใช้แอปพลิเคชันเว้นแต่จะพบ DLL ทั้งหมดที่แอปพลิเคชันอาจต้องการ อย่างไรก็ตาม แอปพลิเคชันอาจเชื่อมโยงกับไลบรารีนำเข้าเพื่ออนุญาตให้โหลดไลบรารีแบบไดนามิกแบบล่าช้า^{[ 6 ]} ในกรณีนี้ ระบบปฏิบัติการจะไม่พยายามค้นหาหรือโหลด DLL เมื่อแอปพลิเคชันเริ่มต้น แต่ตัวเชื่อมโยงจะรวม stub ไว้ในแอปพลิเคชัน ซึ่งจะพยายามค้นหาและโหลด DLL LoadLibraryเมื่อGetProcAddressมีการเรียกใช้ฟังก์ชันใดฟังก์ชันหนึ่ง หากไม่พบหรือโหลด DLL ไม่ได้ หรือฟังก์ชันที่เรียกใช้ไม่มีอยู่ แอปพลิเคชันจะสร้างข้อยกเว้นซึ่งอาจถูกดักจับและจัดการอย่างเหมาะสม หากแอปพลิเคชันไม่จัดการข้อยกเว้น ระบบปฏิบัติการจะดักจับข้อยกเว้นนั้นและยุติโปรแกรมพร้อมข้อความแสดงข้อผิดพลาด

กลไกการโหลดแบบหน่วงเวลายังมีกลไก การแจ้งเตือน ซึ่งช่วยให้แอปพลิเคชันสามารถดำเนินการประมวลผลเพิ่มเติมหรือจัดการข้อผิดพลาดเมื่อโหลด DLL และ/หรือเมื่อมีการเรียกใช้ฟังก์ชันใดๆ ของ DLL

ในไฟล์ต้นฉบับlibraryจะใช้คีย์เวิร์ดแทนprogramในส่วนท้ายของไฟล์ จะมีการระบุฟังก์ชันที่จะส่งออกไว้ในexportsส่วนของเงื่อนไข

Delphiไม่จำเป็นต้องใช้LIBไฟล์เพื่อนำเข้าฟังก์ชันจาก DLL; ในการเชื่อมโยงกับ DLL externalจะใช้คำหลักในคำประกาศฟังก์ชันเพื่อระบุชื่อ DLL ตามด้วยnameชื่อสัญลักษณ์ (ถ้าแตกต่างกัน) หรือindexเพื่อระบุหมายเลขดัชนี

ในVisual Basic (VB) รองรับเฉพาะการเชื่อมโยงขณะรันไทม์เท่านั้น แต่เพิ่มเติมจากการใช้ฟังก์ชัน API แล้วLoadLibraryยังอนุญาตให้ประกาศ ฟังก์ชันที่นำเข้าได้อีกด้วยGetProcAddress

เมื่อนำเข้าฟังก์ชันจาก DLL ผ่านการประกาศ VB จะสร้างข้อผิดพลาดขณะรันไทม์หากDLLไม่พบไฟล์ นักพัฒนาสามารถดักจับข้อผิดพลาดและจัดการได้อย่างเหมาะสม

เมื่อสร้าง DLL ใน VB IDE จะอนุญาตให้สร้างเฉพาะ DLL ของ ActiveX เท่านั้น อย่างไรก็ตาม มีการสร้างวิธีการ^{[ 7 ]}เพื่ออนุญาตให้ผู้ใช้บอกลิงเกอร์อย่างชัดเจนให้รวมไฟล์ .DEF ซึ่งกำหนดตำแหน่งลำดับและชื่อของแต่ละฟังก์ชันที่ส่งออก วิธีนี้ช่วยให้ผู้ใช้สามารถสร้าง DLL มาตรฐานของ Windows โดยใช้ Visual Basic (เวอร์ชัน 6 หรือต่ำกว่า) ซึ่งสามารถอ้างอิงได้ผ่านคำสั่ง "Declare"

Microsoft Visual C++ (MSVC) มีส่วนขยายหลายอย่างสำหรับC++ มาตรฐาน ที่อนุญาตให้ระบุฟังก์ชันเป็นนำเข้าหรือส่งออกโดยตรงในโค้ด C++ ส่วนขยายเหล่านี้ได้รับการนำไปใช้โดย คอมไพเลอร์ Cและ C++ อื่นๆ ของ Windows รวมถึงGCC เวอร์ชัน Windows ส่วนขยายเหล่านี้ใช้แอตทริบิวต์__declspecก่อนการประกาศฟังก์ชัน โปรดทราบว่าเมื่อเข้าถึงฟังก์ชัน C จาก C++ ฟังก์ชันเหล่านั้นจะต้องถูกประกาศในextern "C"โค้ด C++ ด้วย เพื่อแจ้งให้คอมไพเลอร์ทราบว่าควรใช้การเชื่อมโยง C ^{[ 8 ]}

นอกจากการระบุฟังก์ชันที่นำเข้าหรือส่งออกโดยใช้__declspecแอตทริบิวต์แล้ว ฟังก์ชันเหล่านั้นอาจแสดงอยู่ในส่วน IMPORT หรือ EXPORTS ของDEFไฟล์ที่ใช้โดยโปรเจกต์DEFไฟล์ดังกล่าวจะถูกประมวลผลโดยลิงเกอร์ ไม่ใช่คอมไพเลอร์ ดังนั้นจึงไม่จำกัดเฉพาะภาษา C++

การคอมไพล์ DLL จะสร้าง ไฟล์ `.md.js` DLLและLIB`.md.js` LIBไฟล์ `.md.js` (ไลบรารีนำเข้า) ใช้สำหรับการเชื่อมโยงกับ DLL ในระหว่างการคอมไพล์ ไม่จำเป็นสำหรับการเชื่อมโยงในขณะรันไทม์ เว้นแต่ว่า DLL นั้นจะเป็น เซิร์ฟเวอร์ Component Object Model (COM) DLLไฟล์ `.md.js` จะต้องอยู่ในไดเร็กทอรีใดไดเร็กทอรีหนึ่งที่ระบุไว้ในตัวแปรสภาพแวดล้อม PATH ในไดเร็กทอรีระบบเริ่มต้น หรือในไดเร็กทอรีเดียวกับโปรแกรมที่ใช้งาน เซิร์ฟเวอร์ DLL ของ COM จะถูกลงทะเบียนโดยใช้ regsvr32.exe ซึ่งจะบันทึกตำแหน่งของ DLL และรหัสเฉพาะทั่วโลก ( GUID ) ลงในรีจิสทรี จากนั้นโปรแกรมสามารถใช้ DLL ได้โดยการค้นหา GUID ในรีจิสทรีเพื่อค้นหาตำแหน่ง หรือสร้างอินสแตนซ์ของอ็อบเจ็กต์ COM โดยอ้อมโดยใช้ตัวระบุคลาสและตัวระบุอินเทอร์เฟซ

ตัวอย่างต่อไปนี้แสดงวิธีการใช้การผูกค่าเฉพาะภาษาเพื่อนำเข้าสัญลักษณ์สำหรับการเชื่อมโยงกับ DLL ในระหว่างการคอมไพล์

เดลฟี

{$APPTYPE CONSOLE}ตัวอย่างโปรแกรม;// นำเข้าฟังก์ชันที่บวกเลขสองจำนวนฟังก์ชันAddNumbers ( a , b : Double ) : Double ; StdCall ; external 'Example.dll' ;// โปรแกรมหลักvar R : Double ;begin R := AddNumbers ( 1 , 2 ) ; Writeln ( 'ผลลัพธ์คือ: ' , R ) ; end .

ซี

ไฟล์ 'Example.lib' ต้องถูกรวมไว้ในโปรเจ็กต์ก่อนการเชื่อมโยงแบบคงที่ (โดยสมมติว่าไฟล์ Example.dll ถูกสร้างขึ้นแล้ว) ไฟล์ 'Example.lib' จะถูกสร้างขึ้นโดยอัตโนมัติโดยคอมไพเลอร์เมื่อคอมไพล์ DLL การไม่ดำเนินการตามคำสั่งข้างต้นจะทำให้เกิดข้อผิดพลาดในการเชื่อมโยง เนื่องจากตัวเชื่อมโยงจะไม่ทราบว่าจะหาคำจำกัดความของAddNumbersไฟล์ 'Example.lib' ได้จากที่ใด นอกจากนี้ อาจต้องคัดลอกไฟล์ DLL 'Example.dll' ไปยังตำแหน่งที่ไฟล์ .exe จะถูกสร้างขึ้นโดยใช้โค้ดต่อไปนี้:

#include <windows.h> #include <stdio.h>// นำเข้าฟังก์ชันที่บวกเลขสองจำนวนextern "C" __declspec ( dllimport ) double AddNumbers ( double a , double b );int main ( int argc , char * argv []) { double result = AddNumbers ( 1 , 2 ); printf ( "ผลลัพธ์คือ: %f \n " , result ); return 0 ; }

ตัวอย่างต่อไปนี้แสดงวิธีการใช้ฟังก์ชันการโหลดและการเชื่อมโยงขณะรันไทม์ โดยใช้การผูก API ของ Windows ที่เฉพาะเจาะจงสำหรับแต่ละภาษา

โปรดทราบว่าตัวอย่างทั้งสี่ตัวอย่างมีความเสี่ยงต่อการโจมตีการโหลด DLLล่วงหน้า เนื่องจาก example.dll สามารถถูกระบุไปยังตำแหน่งที่ผู้เขียนไม่ได้ตั้งใจ (ไดเร็กทอรีการทำงานปัจจุบันจะอยู่ก่อนตำแหน่งไลบรารีของระบบ) และด้วยเหตุนี้จึงอาจนำไปสู่ไลบรารีเวอร์ชันที่เป็นอันตราย ดูข้อมูลอ้างอิงสำหรับคำแนะนำของ Microsoft เกี่ยวกับการโหลดไลบรารีอย่างปลอดภัย: ควรใช้SetDllDirectoryWin kernel32เพื่อลบการค้นหาไดเร็กทอรีปัจจุบันก่อนที่จะโหลดไลบรารีใดๆ^{[ 9 ]}

Option Explicit Declare Function AddNumbers Lib "Example.dll" _ ( ByVal a As Double , ByVal b As Double ) As DoubleSub Main () Dim Result As Double Result = AddNumbers ( 1 , 2 ) Debug . Print "ผลลัพธ์คือ: " & Result End Sub

โปรแกรมตัวอย่าง; {$APPTYPE CONSOLE} ใช้Windows ; var AddNumbers : ฟังก์ชัน( a , b : จำนวนเต็ม) : Double ; StdCall ; LibHandle : HMODULE ; begin LibHandle := LoadLibrary ( 'example.dll' ) ; if LibHandle <> 0 then AddNumbers := GetProcAddress ( LibHandle , 'AddNumbers' ) ; if Assigned ( AddNumbers ) then Writeln ( '1 + 2 = ' , AddNumbers ( 1 , 2 ) ) ; Readln ; end .

#include <windows.h> #include <stdio.h>// ลายเซ็นฟังก์ชัน DLL typedef double ( * importFunction )( double , double );int main ( int argc , char ** argv ) { importFunction addNumbers ; double result ; HINSTANCE hinstLib ;// โหลดไฟล์ DLL hinstLib = LoadLibrary ( TEXT ( "Example.dll" )); if ( hinstLib == NULL ) { printf ( "ERROR: ไม่สามารถโหลด DLL ได้\n " ); return 1 ; }// รับพอยเตอร์ฟังก์ชันaddNumbers = ( importFunction ) GetProcAddress ( hinstLib , "AddNumbers" ); if ( addNumbers == NULL ) { printf ( "ERROR: unable to find DLL function \n " ); FreeLibrary ( hinstLib ); return 1 ; }// เรียกฟังก์ชันผลลัพธ์= addNumbers ( 1 , 3 );// ยกเลิกการโหลดไฟล์ DLL FreeLibrary ( hinstLib );// แสดงผลลัพธ์printf ( "ผลลัพธ์คือ: %f \n " , result );ส่งคืนค่า0 ; }

นำเข้าctypesmy_dll = ctypes​ ซีดี. LoadLibrary ( "Example.dll" )# จำเป็นต้องระบุเมธอด "restype" ต่อไปนี้เพื่อให้# Python เข้าใจ ว่าฟังก์ชันส่งคืนค่าประเภทใดmy_dll.AddNumbers.restype = ctypes.c_doublep = my_dll.AddNumbers ( ctypes.c_double ( 1.0 ) , ctypes.c_double ( 2.0 ) )​​​​พิมพ์( "ผลลัพธ์คือ:" , หน้า)