แบบฝึกหัด - เรียกใช้วิธีการของคลาส .NET

12 นาที

ไม่ว่าคุณจะตระหนักถึงหรือไม่คุณได้เรียกใช้วิธีการ C# มาตั้งแต่แอปพลิเคชัน "Hello, World!" ครั้งแรกของคุณ โปรแกรมประยุกต์นั้นใช้ WriteLine() เมธอด ของ Console คลาสเพื่อแสดงข้อความ "Hello, World!"

อย่างไรก็ตาม ไม่ได้มีการนําคลาสและวิธีการทั้งหมดมาใช้ในลักษณะเดียวกัน หน่วยนี้ครอบคลุมถึงตัวแปรที่พบบ่อยที่สุดที่คุณจะต้องทําความเข้าใจเมื่อใช้วิธีการจากไลบรารีคลาส .NET ที่สําคัญกว่านั้น คุณจะได้เรียนรู้วิธีการค้นหาและใช้เอกสารเพื่อทําความเข้าใจเพิ่มเติมเกี่ยวกับแต่ละวิธี

วิธีการเรียกใช้วิธีการในไลบรารีคลาส .NET

จากประสบการณ์ก่อนหน้านี้ของคุณ Console.WriteLine() ด้วยวิธีการ คุณควรทราบพื้นฐานอยู่แล้ว:

เริ่มต้นด้วยการพิมพ์ชื่อคลาส ในกรณีนี้ ชื่อคลาสคือConsole
เพิ่มตัวดําเนินการเข้าถึงสมาชิก สัญลักษณ์.
เพิ่มชื่อของวิธีการ ในกรณีนี้ ชื่อของวิธีการคือWriteLine
เพิ่มตัวดําเนินการเรียกใช้เมธอด ซึ่งเป็นชุดของวงเล็บ()
สุดท้าย ระบุอาร์กิวเมนต์ที่ส่งผ่านไปยังเมธอด ถ้ามี ระหว่างวงเล็บของตัวดําเนินการเรียกใช้เมธอด ในกรณีนี้ คุณต้องระบุข้อความที่คุณต้องการให้ Console.WriteLine() วิธีการ เขียนไปยังคอนโซล (ตัวอย่างเช่น "Hello World!")

อีกทางหนึ่งคือ ขึ้นอยู่กับวิธีที่นักพัฒนาออกแบบและนําวิธีการนั้นมาใช้ คุณอาจจําเป็นต้อง:

ส่งผ่านค่าเพิ่มเติมเป็นพารามิเตอร์ข้อมูลป้อนเข้า
ยอมรับค่าที่ส่งกลับ

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

ในขณะที่วิธีการบางอย่างสามารถเรียกใช้ในลักษณะเดียวกับที่คุณเรียกใช้ Console.WriteLine()มีวิธีการอื่น ๆ ในไลบรารีคลาส .NET ที่จําเป็นต้องใช้วิธีการอื่น

เตรียมสภาพแวดล้อมการเข้ารหัสของคุณ

โมดูลนี้ประกอบด้วยกิจกรรมการเขียนโค้ดที่แนะนําคุณตลอดกระบวนการสร้างและเรียกใช้โค้ดตัวอย่าง คุณควรทํากิจกรรมเหล่านี้ให้เสร็จสมบูรณ์โดยใช้ Visual Studio Code เป็นสภาพแวดล้อมการพัฒนาของคุณ การใช้ Visual Studio Code สําหรับกิจกรรมเหล่านี้จะช่วยให้คุณเขียนและเรียกใช้โค้ดในสภาพแวดล้อมของนักพัฒนาที่มืออาชีพใช้ทั่วโลกได้อย่างสะดวกขึ้น

เปิด Visual Studio Code

คุณสามารถใช้เมนูเริ่มต้นของ Windows (หรือทรัพยากรที่เทียบเท่าสําหรับระบบปฏิบัติการอื่น) เพื่อเปิด Visual Studio Code
บนเมนู ไฟล์ รหัส Visual Studio เลือก เปิดโฟลเดอร์
ในกล่องโต้ตอบ เปิดโฟลเดอร์ ให้ไปยังโฟลเดอร์ Windows Desktop

หากคุณมีตําแหน่งโฟลเดอร์อื่นที่คุณเก็บโครงการโค้ดไว้ คุณสามารถใช้ตําแหน่งโฟลเดอร์นั้นแทนได้ สําหรับการฝึกนี้ สิ่งสําคัญคือการมีตําแหน่งที่ตั้งที่ง่ายต่อการค้นหาและจดจํา
ในกล่องโต้ตอบ เปิด โฟลเดอร์ ให้เลือก เลือกโฟลเดอร์

ถ้าคุณเห็นกล่องโต้ตอบความปลอดภัยที่ถามว่าคุณเชื่อถือผู้เขียนหรือไม่ ให้เลือก ใช่
บนเมนู เทอร์มินัล Visual Studio Code ให้เลือก เทอร์มินัลใหม่

โปรดสังเกตว่าพร้อมท์คําสั่งในแผงเทอร์มินัล จะแสดงเส้นทางโฟลเดอร์สําหรับโฟลเดอร์ปัจจุบัน เช่น:
```
C:\Users\someuser\Desktop>
```
หมายเหตุ

ถ้าคุณกําลังทํางานบนพีซีของคุณเองแทนที่จะเป็น Sandbox หรือสภาพแวดล้อมที่เป็นโฮสต์ และคุณจบมอดูล Microsoft Learn อื่นๆ ใน C# ซีรี่ส์นี้ คุณอาจสร้างโฟลเดอร์โครงการสําหรับตัวอย่างโค้ดไว้แล้ว ถ้าเป็นกรณีนี้ คุณสามารถข้ามขั้นตอนถัดไป ซึ่งใช้เพื่อสร้างแอปคอนโซลในโฟลเดอร์ TestProject
ที่พรอมต์คําสั่งเทอร์มินัล หากต้องการสร้างแอปพลิเคชันคอนโซลใหม่ในโฟลเดอร์ที่ระบุ ให้ป้อนพร้อมท์ต่อไปนี้:
```
dotnet new console -o ./CsharpProjects/TestProject
```
คําสั่ง .NET CLI นี้ใช้เทมเพลตโปรแกรม .NET เพื่อสร้างโครงการแอปพลิเคชันคอนโซล C# ใหม่ในตําแหน่งที่ตั้งโฟลเดอร์ที่ระบุ คําสั่งจะสร้างโฟลเดอร์ CsharpProjects และ TestProject ให้คุณ และใช้ TestProject เป็นชื่อของไฟล์ของคุณ.csproj

ถ้ามีข้อความแสดงขึ้นเพื่อบอกให้คุณทราบว่ามีไฟล์อยู่แล้ว ให้ทําตามขั้นตอนถัดไป คุณจะใช้ไฟล์โครงการที่มีอยู่อีกครั้ง
ในมุมมอง EXPLORER ให้ขยายโฟลเดอร์ CsharpProjects

คุณควรเห็นโฟลเดอร์ TestProject และแฟ้มสองแฟ้ม แฟ้มโปรแกรม C# ที่ชื่อว่า Program.cs และแฟ้มโครงการ C# ที่ชื่อ TestProject.csproj
บนเมนู ไฟล์ รหัส Visual Studio เลือก เปิดโฟลเดอร์
ในกล่องโต้ตอบ เปิดโฟลเดอร์ เลือกโฟลเดอร์ CsharpProjects จากนั้นเลือก เลือกโฟลเดอร์
ในมุมมอง EXPLORER ให้ขยายโฟลเดอร์ TestProject จากนั้นเลือก Program.cs
ลบบรรทัดรหัสที่มีอยู่

คุณจะใช้โครงการคอนโซล C# นี้เพื่อสร้าง สร้าง และเรียกใช้ตัวอย่างโค้ดในระหว่างโมดูลนี้
ปิดแผงเทอร์มินัล

เรียกใช้วิธีการชนิดต่างๆ ในไลบรารีคลาส .NET

ใน Visual Studio Code Editor หากต้องการสร้างตัวอย่างโค้ดที่ใช้วิธีการ ของ System.Random คลาส และ System.Console ให้ป้อนรหัสต่อไปนี้:
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
รหัสนี้จะจําลองการม้วนลูกเต๋าโดยใช้ Random.Next() เมธอด เพื่อสร้างตัวเลขและ Console.WriteLine() วิธีการในการแสดงค่า

หมายเหตุ

คุณจะตรวจสอบรหัสอย่างละเอียดในภายหลังในหน่วยนี้
บนเมนู ไฟล์ของ Visual Studio Code ให้คลิก บันทึก
ในมุมมอง EXPLORER เมื่อต้องการเปิดเทอร์มินัลที่ตําแหน่งที่ตั้งโฟลเดอร์ TestProject ของคุณ ให้คลิกขวาที่ TestProject จากนั้นเลือกเปิดในเทอร์มินัลรวม

โปรดสังเกตว่าแผงเทอร์มินัลมีพรอมต์คําสั่งที่แสดงเส้นทางโฟลเดอร์ เช่น:
```
C:\Users\someuser\Desktop\CsharpProjects\TestProject>
```
เมื่อคุณใช้เทอร์มินัลเพื่อเรียกใช้คําสั่ง .NET CLI คําสั่งจะเรียกใช้จากตําแหน่งโฟลเดอร์ที่แสดง ตรวจสอบให้แน่ใจว่าโฟลเดอร์โค้ดของคุณตรงกับเส้นทางโฟลเดอร์ที่แสดงในพร้อมท์คําสั่งก่อนที่คุณจะสร้างหรือเรียกใช้โค้ดของคุณ
ที่พร้อมท์คําสั่งเทอร์มินัล เมื่อต้องการเรียกใช้โค้ดของคุณ ให้พิมพ์ dotnet เรียกใช้ แล้วกด Enter

โปรดสังเกตว่าตัวเลขตั้งแต่ 1 ถึง 6 จะแสดงในเอาต์พุตของคอนโซล (จํานวนจุดบนลูกเต๋า) ถ้าคุณเรียกใช้โค้ดมากพอ คุณจะเห็นตัวเลข 1-6 แต่ละรายการแสดงอยู่
ใช้เวลาสักครู่ในการตรวจสอบไวยากรณ์ที่ใช้ในการเข้าถึงNext()วิธีการ และWriteLine()

โปรดสังเกตว่าคุณใช้เทคนิคที่แตกต่างกันเพื่อเข้าถึงวิธีการ
```
Random dice = new Random();
int roll = dice.Next(1, 7);
Console.WriteLine(roll);
```
บนบรรทัดโค้ดที่สาม คุณสามารถรวมการอ้างอิงไปยัง Console คลาส และเรียกใช้ Console.WriteLine() วิธีการ โดยตรง อย่างไรก็ตาม คุณใช้เทคนิคที่แตกต่างกันสําหรับการเรียก Random.Next() วิธีการ เหตุผลที่คุณใช้สองเทคนิคที่แตกต่างกันคือเพราะบางวิธีการคือ "stateful" และอื่น ๆ เป็นแบบ "ไม่มีสถานะ" คุณตรวจสอบความแตกต่างระหว่างวิธีการแบบ stateful และไม่มีสถานะในส่วนถัดไป

วิธีการแบบไม่ระบุสถานะและไม่มีสถานะ

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

วิธีการบางอย่างไม่ขึ้นอยู่กับสถานะปัจจุบันของแอปพลิเคชันเพื่อให้ทํางานได้อย่างถูกต้อง กล่าวอีกนัยหนึ่ง วิธีการที่ไร้สถานะ จะถูกนํามาใช้เพื่อให้สามารถทํางานได้โดยไม่ต้องอ้างอิงหรือเปลี่ยนแปลงค่าใด ๆ ที่เก็บไว้ในหน่วยความจํา วิธีการแบบไม่ระบุสถานะจะเรียกอีกอย่างว่าวิธีการแบบคงที่

ตัวอย่างเช่น Console.WriteLine() วิธีการ ไม่ได้ขึ้นอยู่กับค่าใด ๆ ที่จัดเก็บไว้ในหน่วยความจํา ซึ่งทําหน้าที่และเสร็จสิ้นโดยไม่ส่งผลกระทบต่อสถานะของแอปพลิเคชันไม่ว่าด้วยวิธีใดก็ตาม

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

วิธีการ Stateful (อินสแตนซ์) ติดตามสถานะของพวกเขาใน เขตข้อมูล ซึ่งเป็นตัวแปรที่กําหนดไว้บนคลาส แต่ละอินสแตนซ์ใหม่ของคลาสจะได้รับสําเนาของเขตข้อมูลที่จะจัดเก็บสถานะของตนเอง

ระดับชั้นเดียวสามารถรองรับวิธีการทั้งแบบรัฐและแบบไม่ระบุรัฐ อย่างไรก็ตาม เมื่อคุณต้องการเรียกใช้เมธอด stateful คุณต้องสร้าง อินสแตนซ์ ของคลาสก่อนเพื่อให้เมธอด สามารถเข้าถึงสถานะได้

การสร้างอินสแตนซ์ของคลาส

อินสแตนซ์ของคลาสถูกเรียกว่าเป็นออบเจ็กต์ หากต้องการสร้างอินสแตนซ์ใหม่ของคลาส คุณต้องใช้ตัว new ดําเนินการ พิจารณาบรรทัดของโค้ดต่อไปนี้ที่สร้างอินสแตนซ์ใหม่ของ Random คลาสเพื่อสร้างออบเจ็กต์ diceใหม่ที่เรียกว่า :

Random dice = new Random();

ตัว new ดําเนินการทําสิ่งสําคัญหลายประการ:

ซึ่งการร้องขอที่อยู่ในหน่วยความจําของคอมพิวเตอร์ที่มีขนาดใหญ่พอที่จะเก็บวัตถุใหม่ที่ยึดตาม Random คลาส
จะสร้างวัตถุใหม่ และจัดเก็บไว้ที่ที่อยู่ของหน่วยความจํา
ซึ่งจะส่งกลับที่อยู่หน่วยความจําเพื่อให้สามารถบันทึกไว้ใน dice วัตถุได้

จากจุดนั้นเมื่อ dice วัตถุถูกอ้างอิงในโค้ด . NET Runtime จะทําการค้นหาเบื้องหลังเพื่อให้ภาพลวงตาที่คุณกําลังทํางานโดยตรงกับวัตถุ

รหัสของคุณใช้วัตถุ dice เช่น ตัวแปรที่จัดเก็บสถานะของ Random คลาส เมื่อคุณเรียกใช้ Next() เมธอด บน dice ออบเจ็กต์ เมธอด จะใช้สถานะที่ dice จัดเก็บไว้ในวัตถุ เพื่อสร้างตัวเลขแบบสุ่ม

เวอร์ชันล่าสุดของ .NET Runtime ช่วยให้คุณสามารถสร้างอินสแตนซ์ของวัตถุโดยไม่ต้องทําซ้ําชื่อชนิด (การเรียกคอนสตรักเตอร์แบบประเภทเป้าหมาย) ตัวอย่างเช่น รหัสต่อไปนี้จะสร้างอินสแตนซ์ใหม่ของ Random คลาส:

Random dice = new();

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

เหตุใดวิธีการ Next() จึงเป็นไปตามสถานะ

คุณอาจสงสัยว่าทําไม Next() วิธีการจึงถูกนํามาใช้เป็นวิธีการที่ชาญฉลาด? ไม่สามารถนักออกแบบไลบรารีคลาส .NET หาวิธีสร้างตัวเลขสุ่มโดยไม่จําเป็นต้องมีสถานะใช่หรือไม่ และอะไรกันแน่ที่ถูกจัดเก็บหรืออ้างอิงโดย Next() เมธอด

นี่เป็นคําถามที่ยุติธรรม ในระดับสูง คอมพิวเตอร์สามารถทําตามคําแนะนําเฉพาะเพื่อสร้างผลลัพธ์ที่เชื่อถือได้และสามารถทําซ้ําได้ หากต้องการสร้างภาพลวงตาของแบบสุ่ม นักพัฒนา Next() ของวิธีการจึงตัดสินใจจับวันที่และเวลาลงไปที่เศษส่วนของมิลลิวินาทีและใช้วิธีนั้นในการดูอัลกอริทึมที่สร้างตัวเลขที่แตกต่างกันในแต่ละครั้ง แม้ว่าจะไม่สุ่มทั้งหมดแต่ก็เพียงพอสําหรับแอปพลิเคชันส่วนใหญ่ สถานะที่รวบรวมและรักษาไว้ตลอดอายุการใช้งานของ dice วัตถุคือค่าข้อมูลเริ่มต้น การเรียกแต่ละครั้งไปยัง Next() เมธอด คือการเรียกใช้อัลกอริทึมใหม่ แต่ตรวจสอบให้แน่ใจว่าการเปลี่ยนแปลงของข้อมูลเริ่มต้นเพื่อไม่ให้ส่งกลับค่าเดียวกัน (จําเป็น)

อย่างไรก็ตาม หากต้องการใช้ Random.Next() วิธีการ คุณไม่จําเป็นต้องเข้าใจ วิธีการ ทํางาน สิ่งสําคัญที่ต้องทราบคือ บางวิธีบังคับให้คุณสร้างอินสแตนซ์ของคลาสก่อนที่คุณจะเรียกใช้ ในขณะที่วิธีอื่นไม่มี

คุณสามารถตรวจสอบได้อย่างไรว่าคุณจําเป็นต้องสร้างอินสแตนซ์ของคลาสก่อนที่จะเรียกใช้วิธีการของคลาสหรือไม่

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

หมายเหตุ

คุณอาจต้องเลื่อนลงในหน้าเอกสารประกอบเพื่อค้นหาตัวอย่างโค้ด

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

ลองเข้าถึง Random.Next() วิธีการโดยตรงและดูสิ่งที่เกิดขึ้น

ป้อนบรรทัดโค้ดต่อไปนี้ลงใน Visual Studio Code Editor:
```
int result = Random.Next();
```
คุณทราบแล้วว่า Next() เป็นวิธีที่เป็นวิธีที่ชาญฉลาด แต่ตัวอย่างนี้แสดงให้เห็นว่า Visual Studio Code Editor มีปฏิกิริยาอย่างไรเมื่อคุณพยายามเข้าถึงเมธอด อย่างไม่ถูกต้อง
โปรดสังเกตว่าเส้นหยักสีแดงปรากฏภายใต้ Random.Nextซึ่งแสดงว่าคุณมีข้อผิดพลาดในการคอมไพล์

ถ้าวิธีการที่คุณสนใจใช้นั้นไม่มีสถานะ เส้นหยักสีแดงจะปรากฏขึ้น
เลื่อนตัวชี้เมาส์ของคุณไปเหนือเส้นหยักสีแดง

หน้าต่างป็อปอัพควรปรากฏขึ้นพร้อมกับข้อความต่อไปนี้:
```
(1,14): error CS0120: An object reference is required for the non-static field, method, or property 'Random.Next()'
```
ตามที่คุณเห็นในรหัสที่จุดเริ่มต้นของหน่วย คุณสามารถแก้ไขข้อผิดพลาดนี้ โดยการสร้างอินสแตนซ์ของ Random คลาสก่อนที่จะเข้าถึง Next() วิธีการ เช่น:
```
Random dice = new Random();
int roll = dice.Next();
```
ในกรณีนี้ Next() มีการเรียกใช้เมธอด โดยไม่มีพารามิเตอร์ข้อมูลป้อนเข้า

สรุป

เมื่อต้องการเรียกใช้เมธอดของคลาสในไลบรารีคลาสของ .NET คุณใช้รูปแบบ ClassName.MethodName()โดยที่ . สัญลักษณ์เป็นตัวดําเนินการเข้าถึงสมาชิกเพื่อเข้าถึงวิธีการที่กําหนดไว้ในคลาส และ () สัญลักษณ์เป็นตัวดําเนินการเรียกใช้วิธีการ
เมื่อเรียกใช้เมธอดแบบไม่มีสถานะ คุณไม่จําเป็นต้องสร้างอินสแตนซ์ใหม่ของคลาสก่อน
เมื่อเรียกใช้เมธอด stateful คุณต้องสร้างอินสแตนซ์ของคลาสและเข้าถึงเมธอด บนออบเจ็กต์
ใช้ตัว new ดําเนินการ เพื่อสร้างอินสแตนซ์ใหม่ของคลาส
อินสแตนซ์ของคลาสถูกเรียกว่าเป็นออบเจ็กต์

คำติชม

หน้านี้มีประโยชน์หรือไม่

แบบฝึกหัด - เรียกใช้วิธีการของคลาส .NET

ตรวจสอบความรู้ของคุณ

คำติชม