กระบวนการรวบรวมไฟล์ .cs เป็น .dll โดยใช้คำสั่ง csc
หลายครั้งเราต้องแยกไฟล์ .cs ออกเป็นไฟล์ .dll โดยมีการดำเนินการดังนี้:
เปิดหน้าต่างคำสั่ง -> ป้อน cmd ลงในคอนโซล -> cd C:WINDOWSMicrosoft.NETFrameworkv1.1.4322
ไปที่ไดเร็กทอรีที่ติดตั้ง vs.net -> รันคำสั่ง csc csc /target:library File.cs -> สร้างไฟล์ .dll ด้วยชื่อที่เกี่ยวข้องในไดเร็กทอรี (ข้อกำหนดเบื้องต้น: ใส่ไฟล์ .cs ใน C: ไดเรกทอรี WINDOWS Microsoft.NETFrameworkv1.1.4322)
มีหลายวิธีในการใช้คำสั่ง csc โปรดดูดังต่อไปนี้
แปล File.cs เพื่อสร้าง File.exe
csc File.cs คอมไพล์ File.cs เพื่อสร้าง File.dll
csc /target:library File.cs คอมไพล์ File.cs และสร้าง My.exe
csc /out:My.exe File.cs รวบรวมไฟล์ C# ทั้งหมดในไดเร็กทอรีปัจจุบันโดยใช้การปรับให้เหมาะสมและกำหนดสัญลักษณ์ DEBUG ผลลัพธ์คือ File2.exe
csc /define:DEBUG /optimize /out:File2.exe *.cs รวบรวมไฟล์ C# ทั้งหมดในไดเร็กทอรีปัจจุบันเพื่อสร้าง File2.dll เวอร์ชันดีบัก ห้ามแสดงโลโก้หรือคำเตือนใดๆ
csc /target:library /out:File2.dll /warn:0 /nologo /debug *.cs รวบรวมไฟล์ C# ทั้งหมดในไดเร็กทอรีปัจจุบันลงใน Something.xyz (DLL)
csc /target:library /out:Something.xyz *.cs คอมไพล์ File.cs เพื่อสร้าง File.dll
csc /target:library File.cs เป็นคำสั่งที่ใช้บ่อยที่สุด จริงๆ แล้วสามารถเขียนเป็น csc /t:library File.cs ได้ mycodebehind.cs คุณสามารถระบุชื่อไฟล์เอาต์พุตได้ด้วยตัวเอง
csc /out:mycodebehind.dll /t:library mycodebehind.cs mycodebehind2.cs ฟังก์ชั่นนี้คือการติดตั้งไฟล์ cs สองไฟล์เป็นไฟล์ .dll ไฟล์เดียว
ตัวอย่าง (นำมาจากอินเทอร์เน็ต)
1. ไลบรารีลิงก์แบบไดนามิก
ไลบรารีลิงก์แบบไดนามิกคืออะไร? DLL สามตัวที่คุณคุ้นเคย เป็นตัวย่อของ Dynamic Link Library (DLL) เป็นไฟล์ปฏิบัติการที่เป็นไลบรารีฟังก์ชันที่ใช้ร่วมกัน การเชื่อมโยงแบบไดนามิกช่วยให้กระบวนการเรียกใช้ฟังก์ชันที่ไม่ได้เป็นส่วนหนึ่งของโค้ดที่ปฏิบัติการได้ รหัสที่ปฏิบัติการได้สำหรับฟังก์ชันจะอยู่ใน DLL ที่มีฟังก์ชันตั้งแต่หนึ่งฟังก์ชันขึ้นไปที่ได้รับการคอมไพล์ เชื่อมโยง และจัดเก็บแยกต่างหากจากกระบวนการที่ใช้ฟังก์ชันเหล่านั้น DLL ยังช่วยในการแบ่งปันข้อมูลและทรัพยากร แอปพลิเคชันหลายตัวสามารถเข้าถึงเนื้อหาของสำเนา DLL ชุดเดียวในหน่วยความจำได้พร้อมกัน
เช่นเดียวกับโปรแกรมเมอร์ส่วนใหญ่ คุณต้องใช้ DLL บ่อยครั้ง คุณเคยรู้สึกบ้างไหมว่าสิ่งนี้ทำให้คุณเกิดข้อผิดพลาดที่ดีในการเขียนโปรแกรมและการเขียนโค้ด วันนี้ฉันต้องการหารือเกี่ยวกับหัวข้อกับคุณ: วิธีสร้างและเรียก DLL (ไลบรารีลิงก์แบบไดนามิก) ใน C# ในความเป็นจริง DLL อนุญาต ฉันจัดระเบียบและเขียนแอปพลิเคชันของเราได้อย่างยืดหยุ่นมากขึ้น ในฐานะนักออกแบบซอฟต์แวร์ ฉันสามารถบรรลุผลการใช้โค้ดซ้ำได้ในระดับสูง ฉันขอแนะนำวิธีการสร้างและเรียก DLL ใน C#
2.งานเตรียมการ
เราต้องให้คำแนะนำสั้นๆ เกี่ยวกับสิ่งที่เรากำลังจะทำต่อไป ในบทความนี้ เราจะใช้ภาษา C# เพื่อสร้างไลบรารีลิงก์แบบไดนามิกที่ชื่อว่า MyDLL.DLL ในไฟล์ไลบรารีลิงก์แบบไดนามิกนี้ เราจะมีสองฟังก์ชัน แลกเปลี่ยนค่าของพารามิเตอร์สองตัว อีกฟังก์ชันหนึ่งคือการค้นหาตัวหารร่วมที่ยิ่งใหญ่ที่สุดของพารามิเตอร์สองตัว จากนั้นสร้างแอปพลิเคชันเพื่อใช้ DLL นี้ เรียกใช้และส่งออกผลลัพธ์
3. สร้าง DLL
มาสร้างไฟล์โค้ด C# สามไฟล์ต่อไปนี้:
1. MySwap.cs
-
ใช้ระบบ;
เนมสเปซ MyMethods
-
SwapClass คลาสสาธารณะ
-
บูลคงที่สาธารณะ Swap (อ้างอิงยาว i, อ้างอิงยาว j)
-
ฉัน = ฉัน+เจ;
เจ = ไอไอ;
ฉัน = ฉัน;
กลับเป็นจริง;
-
-
-
2. MyMaxCD.cs
ใช้ระบบ;
เนมสเปซ MyMethods
-
MaxCDClass คลาสสาธารณะ
-
MaxCD ยาวคงที่สาธารณะ (ยาว i, ยาว j)
-
ยาว a, b, อุณหภูมิ;
ถ้า(i>เจ)
-
ก = ฉัน;
ข = เจ;
-
อื่น
-
ข = ฉัน;
ก = เจ;
-
อุณหภูมิ = เป็น % ข;
ในขณะที่(อุณหภูมิ!=0)
-
ก = ข;
ข = อุณหภูมิ;
อุณหภูมิ = เป็น % ข;
-
กลับข;
-
-
-
ควรสังเกตว่าเมื่อเราสร้างไฟล์ทั้งสองนี้ เราสามารถใช้ Visual Studio.NET หรือโปรแกรมแก้ไขข้อความอื่น ๆ แม้แต่ Notepad แม้ว่าทั้งสองไฟล์นี้จะไม่ได้อยู่ในไฟล์เดียวกัน แต่ก็อยู่ในเนมสเปซเดียวกัน ซึ่งจะทำให้สะดวกสำหรับเราที่จะใช้ทั้งสองวิธีนี้ในอนาคต แน่นอนว่าพวกมันสามารถอยู่ในเนมสเปซที่แตกต่างกันได้ ซึ่งก็ไม่เป็นไร แต่เราจำเป็นต้องอ้างอิงเพียงสองเนมสเปซที่แตกต่างกันเมื่อเรานำไปใช้ ดังนั้น ผู้เขียนแนะนำว่าควรเขียนไว้ใต้เนมสเปซเดียวจะดีกว่า
ภารกิจต่อไปคือเปลี่ยนไฟล์ cs ทั้งสองนี้เป็นไฟล์ DLL ที่เราต้องการ วิธีการคือ: บนระบบปฏิบัติการที่ติดตั้ง Microsoft.NET Framework เราสามารถค้นหาไดเร็กทอรี Microsoft.NET ในไดเร็กทอรีที่ Windows ตั้งอยู่ คอมไพเลอร์ C# มีให้ภายใต้ไดเร็กทอรีนี้ เรียกใช้ CSC.EXE: csc /target:library /out:MyDLL.DLL MySwap.cs MyMaxCD.cs หลังจากเสร็จสิ้น คุณจะพบไฟล์ MyDLL.DLL ที่เราเพิ่งสร้างขึ้นภายใต้ไดเร็กทอรีนี้ ตัวเลือกคอมไพเลอร์ /target:library บอกให้คอมไพเลอร์ส่งออกไฟล์ DLL แทนไฟล์ EXE ตัวเลือกคอมไพเลอร์ /out ตามด้วยชื่อไฟล์จะระบุชื่อไฟล์ DLL หาก /out ไม่ได้ตามด้วยชื่อไฟล์ คอมไพเลอร์จะใช้ไฟล์แรก (MySwap.cs) เป็นชื่อไฟล์ DLL ไฟล์ที่สร้างขึ้นคือไฟล์ MySwap.DLL
ตกลง! งานของเราในการสร้างไฟล์ไลบรารีลิงก์แบบไดนามิกเสร็จสมบูรณ์แล้ว ตอนนี้ถึงเวลาที่เราจะเพลิดเพลินไปกับผลงานของเรา ด้านล่างนี้ ฉันจะแนะนำวิธีใช้ไฟล์ไลบรารีลิงก์แบบไดนามิกที่เราสร้างขึ้น 4. การใช้ DLL เราเพียงแค่เขียนโปรแกรมขนาดเล็กเพื่อทดสอบว่าทั้งสองวิธีที่เราเพิ่งเขียนนั้นถูกต้องหรือไม่ โอเค ตามฉันมา:
MyClient.cs
ใช้ระบบ;
โดยใช้ MyMethods; // ในที่นี้เราอ้างถึงเนมสเปซที่เพิ่งกำหนดไว้ ถ้าเราเขียนทั้งสองไฟล์ในเนมสเปซที่แตกต่างกันสองไฟล์
คลาส MyClient
-
โมฆะสาธารณะคงหลัก (สตริง [] args)
-
ถ้า (args.Length != 2)
-
Console.WriteLine("การใช้งาน: MyClient <num1> <num2>");
กลับ;
-
ยาว num1 = long.Parse (args [0]);
ยาว num2 = long.Parse (args [1]);
SwapClass.Swap(อ้างอิง num1,อ้างอิง num2);
// โปรดทราบว่าการใช้คำสั่งที่จุดเริ่มต้นของไฟล์ช่วยให้คุณสามารถใช้ชื่อคลาสที่ไม่ผ่านการรับรองเพื่ออ้างอิงวิธีการ DLL ในเวลารวบรวม
Console.WriteLine("ผลลัพธ์ของการแลกเปลี่ยนคือ num1 = {0} และ num2 ={1}",num1, num2);
maxcd ยาว = MaxCDClass.MaxCD(num1,num2);
Console.WriteLine("MaxCD ของ {0} และ {1} คือ {2}",num1, num2, maxcd);
-
-
หากต้องการสร้าง MyClient.exe ที่ปฏิบัติการได้ ให้ใช้บรรทัดคำสั่งต่อไปนี้:
csc /out:MyClient.exe /reference:MyDLL.DLL MyClient.cs
ตัวเลือกคอมไพเลอร์ /out บอกให้คอมไพเลอร์ส่งออกไฟล์ EXE และระบุชื่อไฟล์เอาต์พุต (MyClient.exe) ตัวเลือกคอมไพเลอร์ /reference ระบุไฟล์ DLL ที่โปรแกรมอ้างอิง
5. การดำเนินการ
หากต้องการรันโปรแกรมให้ใส่ชื่อไฟล์ EXE ตามด้วยตัวเลขสองตัว เช่น MyClient 123 456
6. เอาท์พุต
ผลลัพธ์ของการแลกเปลี่ยนคือ num1 = 456 และ num2 = 123
ซีดีสูงสุดของ 456 และ 123 คือ 3
7. สรุป
ลิงก์แบบไดนามิกมีข้อดีดังต่อไปนี้:
1. บันทึกหน่วยความจำและลดการดำเนินการสลับ กระบวนการจำนวนมากสามารถใช้ DLL พร้อมกัน โดยแชร์สำเนาของ DLL ในหน่วยความจำ สำหรับแต่ละแอปพลิเคชันที่สร้างด้วยไลบรารีที่เชื่อมโยงแบบคงที่ Windows จะต้องโหลดสำเนาของรหัสไลบรารีในหน่วยความจำแทน
2. ประหยัดพื้นที่ดิสก์ แอปพลิเคชันจำนวนมากสามารถแชร์สำเนาของ DLL บนดิสก์ได้ แต่แต่ละแอปพลิเคชันที่สร้างด้วยไลบรารีที่เชื่อมโยงแบบคงที่จะมีรหัสไลบรารีที่เชื่อมโยงกับอิมเมจที่ปฏิบัติการได้เป็นสำเนาแยกต่างหาก 3. การอัพเกรดเป็น DLL ง่ายกว่า เมื่อฟังก์ชันใน DLL เปลี่ยนแปลง แอปพลิเคชันที่ใช้งานไม่จำเป็นต้องคอมไพล์ใหม่หรือลิงก์ใหม่ตราบใดที่พารามิเตอร์ของฟังก์ชันและค่าที่ส่งคืนไม่เปลี่ยนแปลง ในทางตรงกันข้าม รหัสอ็อบเจ็กต์ที่เชื่อมโยงแบบคงที่ต้องการให้แอปพลิเคชันเชื่อมโยงใหม่เมื่อฟังก์ชันเปลี่ยนไป
4. ให้การสนับสนุนหลังการขาย ตัวอย่างเช่น สามารถปรับเปลี่ยน DLL ไดรเวอร์จอภาพเพื่อรองรับจอภาพที่ไม่พร้อมใช้งานเมื่อมีการจัดส่งแอปพลิเคชันตั้งแต่แรก
5. รองรับโปรแกรมหลายภาษา โปรแกรมที่เขียนด้วยภาษาโปรแกรมที่แตกต่างกันสามารถเรียกใช้ฟังก์ชัน DLL เดียวกันได้ตราบใดที่โปรแกรมเป็นไปตามรูปแบบการเรียกของฟังก์ชัน โปรแกรมและฟังก์ชัน DLL จะต้องเข้ากันได้ตามลำดับที่ฟังก์ชันคาดหวังว่าอาร์กิวเมนต์จะถูกส่งไปยังสแต็ก ไม่ว่าฟังก์ชันหรือแอปพลิเคชันจะรับผิดชอบในการล้างสแต็กหรือไม่ และอาร์กิวเมนต์ใดๆ จะถูกส่งผ่านไปยังรีจิสเตอร์หรือไม่
6. จัดให้มีกลไกในการขยายคลาสไลบรารี MFC คุณสามารถสืบทอดคลาสจากคลาส MFC ที่มีอยู่ และวางไว้ใน DLL ส่วนขยาย MFC สำหรับใช้งานโดยแอปพลิเคชัน MFC
7. ทำให้การสร้างเวอร์ชันสากลเป็นเรื่องง่าย การวางทรัพยากรลงใน DLL จะทำให้การสร้างแอปพลิเคชันเวอร์ชันสากลของคุณง่ายขึ้นมาก คุณสามารถใส่สตริงสำหรับแอปพลิเคชันแต่ละเวอร์ชันภาษาของคุณลงในไฟล์ทรัพยากร DLL แยกต่างหาก และให้เวอร์ชันภาษาที่แตกต่างกันโหลดทรัพยากรที่เหมาะสมได้
ข้อเสียที่อาจเกิดขึ้นประการหนึ่งของการใช้ DLL คือแอปพลิเคชันไม่มีอยู่ในตัวเอง ขึ้นอยู่กับการมีโมดูล DLL ที่แยกต่างหาก