มีอะไรใหม่ใน Visual Basic 2010

นับตั้งแต่กำเนิดของภาษา Visual Basic ในปี 1991 ภาษานี้ก็เป็นเครื่องมือที่มีประสิทธิภาพสูงสำหรับการสร้างแอปพลิเคชัน เกือบ 20 ปีต่อมา ยังคงนำเสนอการผสานรวมกับ Microsoft .NET Framework ได้อย่างง่ายดาย ช่วยให้นักพัฒนาสามารถเขียนแอปพลิเคชันที่ครอบคลุมเดสก์ท็อป โทรศัพท์ เบราว์เซอร์ และแม้แต่ระบบคลาวด์

Microsoft จะเปิดตัว Visual Studio 2010 ในเดือนนี้ซึ่งรวมถึง Visual Basic เวอร์ชัน 10 (บางครั้งเรียกว่า VB 2010 หรือ VB10) รุ่นนี้เป็นรุ่นที่ทรงพลังที่สุดและมีคุณสมบัติที่ช่วยประหยัดเวลามากมายเพื่อช่วยให้นักพัฒนาทำงานได้มากขึ้นโดยใช้โค้ดน้อยลง ที่นี่ คุณจะได้รับเนื้อหาที่จำเป็นทั้งหมดเพื่อทำความเข้าใจและใช้ประโยชน์จาก Visual Basic ใน Visual Studio 2010 อย่างครบถ้วน

วิวัฒนาการร่วม

ในอดีต Visual Basic และ C# ได้รับการพัฒนาโดยทีมที่แยกจากกัน ซึ่งมักส่งผลให้ฟีเจอร์ปรากฏเป็นอันดับแรกในภาษาหนึ่งแล้วจึงปรากฏเป็นภาษาอื่น ตัวอย่างเช่น C# มีคุณสมบัติที่ปรับใช้อัตโนมัติและตัวเริ่มต้นการรวบรวมที่ไม่พบใน Visual Basic และ Visual Basic มีคุณสมบัติต่างๆ เช่น การผูกล่าช้าและพารามิเตอร์ทางเลือกที่ไม่พบใน C# แต่ทุกครั้งที่ภาษาได้รับฟีเจอร์ใหม่ ลูกค้าจำนวนมากขอให้เพิ่มฟีเจอร์นั้นในภาษาอื่นด้วย

เพื่อตอบสนองความต้องการนี้ Microsoft ได้รวมทีม Visual Basic และ C# เพื่อใช้กลยุทธ์การพัฒนาร่วมกัน มีวัตถุประสงค์เพื่อส่งเสริมการพัฒนาร่วมกันของภาษาเหล่านี้ เมื่อมีการแนะนำคุณลักษณะหลักในภาษาหนึ่ง คุณลักษณะดังกล่าวจะปรากฏในภาษาอื่นด้วย ไม่ได้หมายความว่าทุกฟีเจอร์จะมีอยู่ในทั้งสองภาษาและทำงานในลักษณะเดียวกัน จริงๆ แล้ว แต่ละภาษามีประวัติ จิตวิญญาณ และความรู้สึกเป็นของตัวเอง และสิ่งสำคัญคือต้องรักษาคุณลักษณะเหล่านี้ไว้

ใน .NET Framework 4 นั้น Visual Basic และ C# ได้ก้าวไปสู่เป้าหมายนี้ โดยแต่ละคุณสมบัติได้ดูดซับคุณสมบัติที่มีอยู่มากมายของอีกคุณสมบัติหนึ่ง อย่างไรก็ตาม วิวัฒนาการร่วมไม่เพียงแต่ส่งผลต่อฟังก์ชันการทำงานก่อนหน้านี้เท่านั้น แต่ยังเป็นกลยุทธ์สำหรับการพัฒนาภาษาเหล่านี้ในอนาคตอีกด้วย ด้วยเจตนารมณ์นี้ .NET Framework 4 นำเสนอคุณลักษณะใหม่ที่มีประสิทธิภาพในทั้งสองภาษา เช่น รันไทม์ภาษาไดนามิก ประเภทการทำงานร่วมกันแบบฝัง และความแปรปรวนทั่วไป ช่วยให้นักพัฒนา Visual Basic และ C# สามารถใช้ประโยชน์จาก .NET Framework ได้อย่างเต็มที่

มีอะไรใหม่ใน Visual Basic 2010

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

อักขระต่อเนื่องของบรรทัดโดยนัย

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

ใน Visual Basic 2010 คอมไพเลอร์สามารถแก้ไขปัญหานี้ได้ ตอนนี้คอมไพเลอร์รู้แล้วว่าโทเค็นใด (เช่น เครื่องหมายจุลภาค วงเล็บ และตัวดำเนินการ) มีแนวโน้มที่จะปรากฏก่อนอักขระที่ต่อเนื่องกันของบรรทัด และจะแทรกอักขระเพื่อให้นักพัฒนาไม่จำเป็นต้องแทรกอักขระอีกต่อไป ตัวอย่างเช่น มันไม่สมเหตุสมผลเลยที่จะจบคำสั่ง Visual Basic ด้วยเครื่องหมายจุลภาค ดังนั้นเมื่อคอมไพเลอร์เห็นกระแสของโทเค็น เช่น {comma, enter} มันจะอนุมานว่ามีอักขระต่อเนื่องของบรรทัด ดังแสดงในรูปที่ 1 แสดงตัวอย่าง

รูปที่ 1 อนุมานอักขระต่อเนื่องของบรรทัด

<Extension()>

ฟังก์ชั่น FilterByCountry(

ลูกค้า ByVal ในฐานะ IEnumerable (ของลูกค้า)

ByVal ประเทศ As String) As IEnumerable (ของลูกค้า)

แบบสอบถามติ่มซำ=

จากลูกค้าซีอิน

โดยที่ c.Country = ประเทศ

เลือก <ลูกค้า>

-

ค.ชื่อ &

-

ค.ประเทศ

-

</ลูกค้า>

ส่งคืนแบบสอบถาม

ฟังก์ชันสิ้นสุด

ใน Visual Basic 2008 โค้ดในรูปที่ 1 จะต้องมีอักขระขีดล่าง 9 ตัว อย่างไรก็ตาม ในแต่ละกรณีต่อไปนี้ คอมไพลเลอร์จะอนุมานเมื่อจำเป็นต้องใช้อักขระขีดล่าง และอนุญาตให้ละเว้นได้:

หลังแอตทริบิวต์ <Extension()>

หลัง ((วงเล็บซ้าย) ในการประกาศเมธอด

หลัง , (ลูกน้ำ) ของพารามิเตอร์แรก

ก่อน ) (วงเล็บขวา) ในการประกาศเมธอด

หลัง = (เครื่องหมายเท่ากับ)

หลัง <%= (แท็กเปิดของนิพจน์ที่ฝังไว้)

หลังจากแต่ละเครื่องหมายและ (เครื่องหมายและ) ในข้อความ XML

ก่อน %> (แท็กปิดท้ายของนิพจน์ที่ฝังไว้)

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

รูปที่ 2 เมื่ออักขระต่อเนื่องของบรรทัดเป็นนัย

อย่างที่คุณเห็น มีมากกว่า 60 ตำแหน่งในภาษาที่ไม่ต้องใช้อักขระขีดล่าง (อันที่จริง ไม่มีตัวอย่างโค้ดในบทความนี้จำเป็นต้องมีอักขระต่อเนื่องของบรรทัด) แน่นอน คุณยังคงสามารถใช้อักขระขีดล่างได้ ดังนั้นโค้ดจาก Visual Basic เวอร์ชันก่อนหน้าจะยังคงคอมไพล์ตามที่คาดไว้

คำชี้แจงแลมบ์ดา

คำว่า lambda อาจฟังดูน่ากลัวในตอนแรก แต่ lambda เป็นเพียงฟังก์ชันที่กำหนดไว้ภายในฟังก์ชันอื่น Visual Basic 2008 เปิดตัวนิพจน์ lambda ด้วยคำสำคัญ Function:

Dim customers As Customer() = ...

Array.FindAll (ลูกค้า, ฟังก์ชั่น (c) c.Country = แคนาดา)

นิพจน์ Lambda ช่วยให้คุณสามารถแสดงตรรกะภายในเครื่องได้อย่างละเอียดและกะทัดรัด โดยไม่ต้องแยกออกเป็นหลายๆ วิธี ตัวอย่างเช่น นี่คือการแสดงโค้ดก่อนหน้าใน Visual Basic 2005 (ซึ่งไม่รองรับนิพจน์แลมบ์ดา):

Dim query = Array.FindAll(customers, AddressOf Filter)

-

ฟังก์ชั่นตัวกรอง (ByVal c ในฐานะลูกค้า) เป็นบูลีน

กลับ c.Country = แคนาดา

ฟังก์ชันสิ้นสุด

ขออภัย นิพจน์แลมบ์ดาของ Visual Basic 2008 จำเป็นต้องมีนิพจน์เพื่อส่งคืนค่า ดังนั้นโค้ดต่อไปนี้:

Array.ForEach(customers, Function(c) Console.WriteLine(c.Country))

จะนำไปสู่สถานการณ์ต่อไปนี้:

'Compile error: Expression does not produce a value.

Console.WriteLine เป็นโพรซีเดอร์ย่อย (เป็นโมฆะใน C#) ดังนั้นจึงไม่ส่งคืนค่า ซึ่งเป็นสาเหตุที่คอมไพเลอร์สร้างข้อผิดพลาด เพื่อจัดการกับสถานการณ์นี้ Visual Basic 2010 ได้แนะนำการสนับสนุนสำหรับคำสั่ง lambdas ซึ่งเป็น lambdas ที่มีคำสั่งตั้งแต่หนึ่งคำสั่งขึ้นไป:

Array.ForEach(customers, Sub(c) Console.WriteLine(c.Country))

เนื่องจาก Console.WriteLine ไม่คืนค่า เราจึงสามารถสร้าง Sub lambda แทน Function lambda ได้ นี่เป็นอีกตัวอย่างหนึ่งที่ใช้หลายคำสั่ง:

Array.ForEach(customers, Sub(c)

Console.WriteLine(ชื่อประเทศ:)

Console.WriteLine (c.ประเทศ)

จบย่อย)

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

AddHandler b.Click, Sub(sender As Object, e As EventArgs)

MsgBox(คลิกปุ่มแล้ว)

'ใส่ตรรกะที่ซับซ้อนมากขึ้นที่นี่

จบหมวดย่อย

และในความเป็นจริง คุณสามารถใช้คำสั่ง lambdas กับฟีเจอร์ที่นำมาใช้ใน Visual Basic 2008 ได้ นั่นคือ การมอบหมายแบบหลวมๆ (คุณสามารถใช้ผู้รับมอบสิทธิ์ - ตัวชี้ฟังก์ชันประเภทปลอดภัย - เพื่อดำเนินการหลายฟังก์ชันพร้อมกัน) การรวมกันนี้ส่งผลให้ลายเซ็นง่ายขึ้นมาก:

AddHandler b.Click, Sub()

MsgBox(คลิกปุ่มแล้ว)

'ใส่ตรรกะที่ซับซ้อนกว่านี้ที่นี่

จบหมวดย่อย

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

นอกจาก lambdas แบบบรรทัดเดียวและ lambdas แบบหลายบรรทัดที่เราเคยเห็นมาแล้ว Visual Basic 2010 ยังสนับสนุน lambdas ฟังก์ชั่นแบบหลายบรรทัดด้วย:

Dim query = customers.Where(Function(c)

'คืนเฉพาะลูกค้าที่ยังไม่ได้บันทึก'

'ใส่ตรรกะที่ซับซ้อนกว่านี้ที่นี่

ส่งกลับ c.ID = -1

ฟังก์ชั่นสิ้นสุด)

อีกแง่มุมที่น่าสนใจของคำสั่ง lambda คือวิธีที่พวกมันตัดกันกับผู้ร่วมประชุมที่ไม่ระบุชื่อที่นำมาใช้ใน Visual Basic 2008 ผู้คนมักสับสนกับวิธีการที่ไม่เปิดเผยตัวตนของ C# แม้ว่าวิธีการเหล่านั้นจะไม่เหมือนกันก็ตาม การมอบหมายแบบไม่ระบุชื่อเกิดขึ้นเมื่อคอมไพเลอร์ Visual Basic อนุมานประเภทผู้รับมอบสิทธิ์ตามลายเซ็นวิธีการของแลมบ์ดา:

Dim method = Function(product As String)

ถ้าสินค้า=กระดาษแล้ว

ส่งคืน 4.5 'หน่วยในสต็อก

อื่น

ส่งคืน 10 '10 ของอย่างอื่นทั้งหมด

สิ้นสุดถ้า

ฟังก์ชันสิ้นสุด

MsgBox(วิธี(กระดาษ))

หากคุณเรียกใช้โค้ดนี้ คุณจะเห็นค่า 4.5 แสดงอยู่ในกล่องข้อความ นอกจากนี้ หากคุณโฮเวอร์เหนือเมธอด คุณจะเห็นข้อความ Dim method As <Function(String) As Double> เนื่องจากเราไม่ได้ระบุประเภทผู้รับมอบสิทธิ์จริง คอมไพเลอร์จะสร้างประเภทดังกล่าวโดยอัตโนมัติดังนี้:

Delegate Function $compilerGeneratedName$(product As String) As Double

สิ่งนี้เรียกว่าผู้รับมอบสิทธิ์ที่ไม่ระบุชื่อเนื่องจากจะปรากฏเฉพาะในโค้ดที่สร้างโดยคอมไพเลอร์เท่านั้น ไม่ใช่ในโค้ดตามที่เขียนไว้ โปรดทราบว่าเมื่อไม่มีการกำหนด As clause ไว้เพื่อระบุประเภทการส่งคืนของแลมบ์ดา คอมไพลเลอร์จะอนุมานประเภทการส่งคืนเป็น Double คอมไพลเลอร์จะดูคำสั่งส่งคืนทั้งหมดภายในแลมบ์ดา และจะกำหนดประเภท Double (4.5) และ Integer (10):

'Notice the As Single

วิธี Dim = Function (ผลิตภัณฑ์ As String) เป็น Single

ถ้าสินค้า=กระดาษแล้ว

ส่งคืน 4.5 'หน่วยในสต็อก

อื่น

ส่งคืน 10 '10 ของอย่างอื่นทั้งหมด

สิ้นสุดถ้า

ฟังก์ชันสิ้นสุด

จากนั้นจะรันอัลกอริธึมประเภทพื้นฐานและกำหนดว่าสามารถแปลง 10 เป็น Double ได้อย่างปลอดภัย แต่ไม่สามารถแปลง 4.5 เป็น Integer ได้อย่างปลอดภัย ดังนั้น Double จึงเป็นตัวเลือกที่ดีกว่า

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

Dim method As Func(Of String, Single) =

ฟังก์ชั่น(สินค้า)

ถ้าสินค้า=กระดาษแล้ว

ส่งคืน 4.5 'หน่วยในสต็อก

อื่น

ส่งคืน 10 '10 ของอย่างอื่นทั้งหมด

สิ้นสุดถ้า

ฟังก์ชันสิ้นสุด

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

Delegate Function Func(Of T, R)(ByVal param As T) As R

มีข้อยกเว้นเล็กๆ น้อยๆ ประการหนึ่ง ดังที่เราจะเห็นในภายหลังในส่วนเรื่องความแปรปรวนทั่วไป

คุณสมบัติที่นำไปใช้อัตโนมัติ

ใน Visual Basic คุณสมบัติคือสมาชิกของคลาสที่เปิดเผยสถานะของวัตถุสู่โลกภายนอก คำประกาศทรัพย์สินโดยทั่วไปมีลักษณะดังนี้:

Private _Country As String

ประเทศทรัพย์สินเป็นสตริง

รับ

กลับ_ประเทศ

จบรับ

ตั้งค่า (ค่า ByVal เป็นสตริง)

_ประเทศ = ค่า

จบเซต

สิ้นสุดคุณสมบัติ

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

Property Country As String

ในกรณีนี้ คอมไพเลอร์จะยังคงรันต่อไปและสร้างฟิลด์ getters, setters และสนับสนุนโดยอัตโนมัติ ชื่อของฟิลด์ที่ได้รับการสนับสนุนจะเป็นชื่อของแอตทริบิวต์ที่นำหน้าด้วยอักขระขีดล่างเสมอ: _Country ในตัวอย่างนี้ แบบแผนการตั้งชื่อนี้รับประกันความเข้ากันได้ของซีเรียลไลซ์แบบไบนารีเมื่อเปลี่ยนคุณสมบัติที่ปรับใช้อัตโนมัติเป็นคุณสมบัติปกติ การทำให้เป็นอนุกรมแบบไบนารีจะยังคงทำงานต่อไปตราบเท่าที่ชื่อของฟิลด์สำรองเหมือนกัน

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

Property ID As Integer = -1

เมื่อตัวสร้างทำงาน ฟิลด์สำรอง (_ID) จะถูกตั้งค่าเป็นค่า -1 โดยอัตโนมัติ ไวยากรณ์ Initializer ยังใช้ได้กับประเภทการอ้างอิง:

Property OrderList As List(Of Order) = New List(Of Order)

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

Property OrderList As New List(Of Order)

คุณยังสามารถใช้ไวยากรณ์นี้กับตัวเริ่มต้นวัตถุเพื่ออนุญาตให้ตั้งค่าคุณสมบัติอื่น ๆ ได้:

Property OrderList As New List(Of Order) With {.Capacity = 100}

แน่นอนว่าสำหรับคุณสมบัติที่ซับซ้อนมากขึ้น ยังจำเป็นต้องมีไวยากรณ์เพิ่มเติม คุณยังคงสามารถพิมพ์ Property{Tab} เพื่อเปิดใช้งานส่วนคุณสมบัติเก่าได้ หรืออีกทางหนึ่ง หลังจากพิมพ์บรรทัดแรกของคุณสมบัติ คุณสามารถป้อน Get{Enter} แล้ว IDE จะสร้างคุณสมบัติแบบเก่า:

Property Name As String

รับ

จบรับ

ตั้งค่า (ค่า ByVal เป็นสตริง)

จบเซต

สิ้นสุดคุณสมบัติ

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

โครงสร้างพื้นฐานการเชื่อมโยงข้อมูล .NET ส่วนใหญ่ทำงานในแง่ของคุณสมบัติมากกว่าฟิลด์

อินเทอร์เฟซไม่สามารถบังคับใช้การมีอยู่ของฟิลด์ได้ แต่สามารถบังคับใช้การมีอยู่ของแอตทริบิวต์ได้

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

ตัวเริ่มต้นการรวบรวม

แนวทางปฏิบัติทั่วไปของ .NET คือการสร้างอินสแตนซ์ของคอลเลกชัน จากนั้นเติมคอลเลกชันโดยการเรียกเมธอด Add หนึ่งครั้งสำหรับแต่ละองค์ประกอบ:

Dim digits As New List(Of Integer)

หลัก.เพิ่ม(0)

หลัก.บวก(1)

หลัก.บวก(2)

หลัก.บวก(3)

หลัก.บวก(4)

หลักบวก(5)

หลักบวก(6)

หลักบวก(7)

หลัก.บวก(8)

หลักบวก(9)

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

Dim digits = New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

คอมไพเลอร์จะสร้างการเรียกทั้งหมดไปยังเมธอด Add โดยอัตโนมัติ คุณยังสามารถใช้ฟังก์ชันไวยากรณ์ As New ของ Visual Basic ได้:

Dim digits As New List(Of Integer) From {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}

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

คุณสามารถใช้ตัวเริ่มต้นการรวบรวมกับประเภทใดก็ได้ที่ตรงตามข้อกำหนดต่อไปนี้:

คุณสามารถวนซ้ำประเภทโดยใช้คำสั่ง For Each นั่นคือประเภทที่ใช้ IEnumerable (สำหรับคำจำกัดความที่ชัดเจน/ละเอียดยิ่งขึ้นของประเภทคอลเลกชัน โปรดดูส่วนที่ 10.9.3 ของข้อกำหนดภาษา Visual Basic ที่ msdn.microsoft.com/library/aa711986(VS.71).aspx)

ประเภทนี้มีตัวสร้างแบบไม่มีพารามิเตอร์ที่สามารถเข้าถึงได้ (แต่ไม่จำเป็นต้องเป็นแบบสาธารณะ)

ประเภทนี้มีอินสแตนซ์หรือวิธีการขยายที่สามารถเข้าถึงได้ (แต่ไม่จำเป็นต้องเป็นสาธารณะ) ชื่อ Add

ซึ่งหมายความว่า คุณยังสามารถใช้ตัวเริ่มต้นคอลเลกชันสำหรับประเภทที่ซับซ้อนมากขึ้น เช่น พจนานุกรม:

Dim lookupTable As New Dictionary(Of Integer, String) From

{{1, หนึ่ง},

{2, สอง},

{3, สาม},

{4, สี่}}

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

Dim lookupTable As New Dictionary(Of Integer, String)

lookupTable.Add(1, หนึ่ง)

lookupTable.Add(2, สอง)

lookupTable.Add(3, สาม)

lookupTable.Add(4, สี่)

คอมไพเลอร์กำลังเรียกเมธอด Add ด้วยพารามิเตอร์สองตัวแทนที่จะเป็นตัวเดียว มันรู้ว่าจะต้องทำเช่นนี้เพราะค่าที่ส่งไปยังตัวเริ่มต้นการรวบรวมนั้นอยู่ภายในวงเล็บปีกกาที่ซ้อนกัน เช่นนี้: {{1, One}, {2, Two}, …} สำหรับแต่ละชุดของวงเล็บปีกกาที่ซ้อนกัน คอมไพเลอร์พยายามส่งพารามิเตอร์เหล่านี้ไปยังเมธอด Add ที่เข้ากันได้

คุณยังสามารถจัดเตรียมการใช้งาน Add ที่คุณกำหนดเองได้โดยใช้วิธีการขยาย:

<Extension()>

เพิ่มย่อย (แหล่งที่มา ByVal เป็น IList (ของลูกค้า)

ByVal id เป็นจำนวนเต็ม

ByVal ชื่อเป็นสตริง

ByVal เมืองเป็นสตริง)

source.Add(ลูกค้าใหม่ด้วย

-

.ไอดี = ไอดี

.ชื่อ = ชื่อ

.เมือง = เมือง

-

จบหมวดย่อย

(ดูอักขระขีดล่างที่หายไปทั้งหมด!) วิธีการนี้จะขยายประเภทใด ๆ ที่ใช้ IList (ของลูกค้า) ซึ่งจะอนุญาตให้คุณใช้ไวยากรณ์ตัวเริ่มต้นคอลเลกชันใหม่เช่นนี้:

Dim list = New List(Of Customer) From

-

{1, จอน, เรดมอนด์},

{2, บ๊อบ, ซีแอตเทิล},

{3, แซลลี่, โตรอนโต}

-

(เพิ่มลูกค้าสามรายลงในรายการ) คุณยังสามารถใช้ตัวเริ่มต้นการรวบรวมกับคุณสมบัติที่นำไปใช้โดยอัตโนมัติ:

Property States As New List(Of String) From {AL, AK, AR, AZ, ...}

ตัวอักษรอาร์เรย์

นอกเหนือจากวิธีที่มีประสิทธิภาพมากขึ้นในการทำงานกับประเภทคอลเลกชันแล้ว Visual Basic 2010 ยังมีการปรับปรุงที่มีประสิทธิภาพสำหรับการทำงานกับอาร์เรย์อีกด้วย สมมติว่ารหัสต่อไปนี้ (ทำงานได้ดีในเวอร์ชันเก่า):

Dim numbers As Integer() = New Integer() {1, 2, 3, 4, 5}

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

Dim numbers = {1, 2, 3, 4, 5}

ประเภทของตัวเลขไม่ใช่ Object แต่เป็น Integer() (ตราบเท่าที่ Option Infer ถูกเปิดใช้งาน) เหตุผลก็คือตอนนี้อาร์เรย์ลิเทอรัลแทนตัวมันเองและมีประเภทของตัวเอง สมมติว่าตัวอย่างที่ซับซ้อนกว่านี้:

Dim numbers = {1, 2, 3, 4, 5.555}

ในกรณีนี้ ประเภทของตัวเลขจะอนุมานเป็น Double() คอมไพเลอร์กำหนดประเภทโดยการตรวจสอบแต่ละองค์ประกอบในอาร์เรย์และคำนวณประเภทพื้นฐาน โดยใช้อัลกอริทึมเดียวกันกับที่กล่าวถึงก่อนหน้านี้เพื่ออนุมานประเภทการส่งคืนของคำสั่ง lambda จะเกิดอะไรขึ้นหากไม่มีประเภทพื้นฐาน? ตัวอย่างเช่น ดังแสดงในรหัสต่อไปนี้:

Dim numbers = {1, 2, 3, 4, 5}

ในกรณีนี้ การแปลงจำนวนเต็มเป็นสตริงจะลดช่วงการแปลง (นั่นคือ ข้อมูลสูญหายอาจเกิดขึ้นเมื่อรันไทม์) และในทำนองเดียวกัน การแปลงสตริงเป็นจำนวนเต็มจะลดช่วงการแปลงด้วย ประเภทที่ปลอดภัยเพียงประเภทเดียวให้เลือกคือ Object() (คอมไพเลอร์จะสร้างข้อผิดพลาดหากเปิดใช้งาน Option Strict)

ตัวอักษรอาร์เรย์สามารถซ้อนกันเพื่อสร้างอาร์เรย์หลายมิติหรืออาร์เรย์หยัก:

'2-dimensional array

เมทริกซ์สลัว = {{1, 0}, {0, 1}}

'อาร์เรย์หยัก - การประเมินแรงในวงเล็บของอาร์เรย์ภายในก่อน

รอยหยักมัว = { ({1, 0}), ({0, 1}) }

รันไทม์ภาษาแบบไดนามิก

แม้ว่า Visual Basic จะเป็นภาษาสแตติกในทางเทคนิค แต่ก็มีฟีเจอร์ไดนามิกที่ทรงพลังอยู่เสมอ เช่น การเชื่อมโยงล่าช้า Visual Studio 2010 มาพร้อมกับแพลตฟอร์มใหม่ที่เรียกว่า Dynamic Language Runtime (DLR) ซึ่งช่วยให้สร้างภาษาไดนามิกและสื่อสารระหว่างกันได้ง่ายขึ้น Visual Basic 2010 ได้รับการอัปเดตเพื่อรองรับ DLR อย่างสมบูรณ์ใน late Binder ช่วยให้นักพัฒนาสามารถใช้ไลบรารีและเฟรมเวิร์กที่พัฒนาในภาษาอื่น (เช่น IronPython/IronRuby)

ข้อได้เปรียบที่โดดเด่นของคุณสมบัตินี้คือไม่มีการเปลี่ยนแปลงทางวากยสัมพันธ์ (อันที่จริงไม่มีการแก้ไขโค้ดแม้แต่บรรทัดเดียวในคอมไพเลอร์เพื่อรองรับคุณสมบัตินี้) นักพัฒนายังคงสามารถดำเนินการผูกล่าช้าได้เหมือนที่เคยทำใน Visual Basic เวอร์ชันก่อนหน้า สิ่งที่มีการเปลี่ยนแปลงคือรหัสในรันไทม์ Visual Basic (Microsoft.VisualBasic.dll) ซึ่งขณะนี้รู้จักอินเทอร์เฟซ IDynamicMetaObjectProvider ที่ได้รับจาก DLR หากวัตถุใช้อินเทอร์เฟซนี้ รันไทม์ Visual Basic จะสร้าง DLR CallSite และอนุญาตให้วัตถุและภาษาที่จัดเตรียมไว้เพื่อแทรกความหมายของตนเองลงในการดำเนินการ

ตัวอย่างเช่น ไลบรารีมาตรฐาน Python มีไฟล์ชื่อ Random.py ซึ่งมีเมธอดที่เรียกว่า shuffle ซึ่งสามารถใช้เพื่อสุ่มจัดเรียงองค์ประกอบในอาร์เรย์ใหม่ได้ การเรียกวิธีนี้นั้นง่ายมาก:

Dim python As ScriptRuntime = Python.CreateRuntime()

สุ่มสลัวเป็นวัตถุ = python.UseFile (random.py)

รายการติ่มซำ = {1, 2, 3, 4, 5, 6, 7}

สุ่มสับเปลี่ยน(รายการ)

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

นี่คือตัวอย่างของการเรียก API ที่เปิดใช้งาน DLR แต่นักพัฒนาสามารถสร้าง API ของตนเองที่ใช้ฟังก์ชันนี้ได้ กุญแจสำคัญคือการใช้อินเทอร์เฟซ IDynamicMetaObjectProvider ซึ่งในกรณีนี้คอมไพเลอร์ Visual Basic และ C# จะจดจำวัตถุที่มีความหมายไดนามิกพิเศษ โปรดอย่าใช้อินเทอร์เฟซนี้ด้วยตนเอง เนื่องจากจะง่ายกว่าที่จะสืบทอดจากคลาส System.Dynamic.DynamicObject (ซึ่งใช้อินเทอร์เฟซนี้อยู่แล้ว) และแทนที่วิธีการเพียงไม่กี่วิธีเท่านั้น รูปที่ 3 แสดงตัวอย่างที่สมบูรณ์ของการสร้างวัตถุไดนามิกแบบกำหนดเอง (ถุงคุณสมบัติที่ปรากฏขึ้นเพื่อสร้างคุณสมบัติได้ทันที) และการใช้การเชื่อมโยงล่าช้าของ Visual Basic ปกติเพื่อเรียกวัตถุ (สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการใช้ DynamicObject โปรดอ่านบทความที่ยอดเยี่ยมของ Doug Rothaus ที่ blogs.msdn.com/vbteam/archive/2010/01/20/fun-with-dynamic-objects-doug-rothaus.aspx )

รูปที่ 3 สร้างวัตถุไดนามิกแบบกำหนดเอง และเรียกวัตถุโดยใช้การรวมล่าช้าของ Visual Basic

Imports System.Dynamic

โมดูล โมดูล1

หลักย่อย()

Dim p As Object = New PropertyBag

น.หนึ่ง = 1

หน้าสอง = 2

หน้าสาม = 3

Console.WriteLine (หน้าหนึ่ง)

Console.WriteLine (หน้าสอง)

Console.WriteLine (หน้าสาม)

จบหมวดย่อย

Class PropertyBag : สืบทอด DynamicObject

ค่าส่วนตัวเป็นพจนานุกรมใหม่ (ของสตริง, จำนวนเต็ม)

ฟังก์ชั่นการแทนที่สาธารณะ TrySetMember (

ByVal binder ในฐานะ SetMemberBinder

ค่า ByVal เป็นวัตถุ) เป็นบูลีน

ค่า(binder.Name) = ค่า

กลับเป็นจริง

ฟังก์ชันสิ้นสุด

ฟังก์ชั่นการแทนที่สาธารณะ TryGetMember (

ByVal binder ในฐานะ GetMemberBinder

ByRef result As Object) เป็นบูลีน

ส่งกลับค่าTryGetValue(binder.Name, result)

ฟังก์ชันสิ้นสุด

จบคลาส

โมดูลสิ้นสุด

ความแปรปรวนทั่วไป

นี่เป็นฟังก์ชันที่อาจฟังดูซับซ้อนในตอนแรก (ด้วยเงื่อนไขอย่างความแปรปรวนร่วมและความแปรปรวนร่วม) แต่จริงๆ แล้วค่อนข้างง่าย หากคุณมีวัตถุประเภท IEnumerable(Of Apple) และต้องการกำหนดให้กับ IEnumerable(Of Fruit) สิ่งนี้ควรจะถูกกฎหมายเพราะ Apple ทุกตัวเป็นผลไม้ (บังคับใช้โดยการสืบทอด) น่าเสียดายที่ก่อน Visual Basic 2010 ความแปรปรวนทั่วไปไม่ได้รับการสนับสนุนในคอมไพเลอร์ แม้ว่าจริงๆ แล้วจะได้รับการสนับสนุนใน Common Language Runtime (CLR) ก็ตาม

ลองมาดูตัวอย่างในรูปที่ 4 กัน ใน Visual Basic 2008 รหัสในรูปที่ 4 จะสร้างข้อผิดพลาดในการคอมไพล์บนบรรทัด Dim EnableOnly (หรือถ้าปิดใช้งาน Option Strict จะมีข้อยกเว้นรันไทม์) วิธีแก้ปัญหาคือการเรียกวิธีการขยาย .Cast ดังต่อไปนี้:

'Old way, the call to Cast(Of Control) is no longer necessary in VB 2010

Dim EnabledOnly = FilterEnabledOnly (buttons.Cast (ของการควบคุม))

สิ่งนี้ไม่จำเป็นอีกต่อไปเนื่องจากใน Visual Basic 2010 อินเทอร์เฟซ IEnumerable ได้รับการทำเครื่องหมายเป็นตัวแปรร่วมโดยใช้ตัวดัดแปลง Out:

Interface IEnumerable(Of Out T)

-

สิ้นสุดอินเทอร์เฟซ

รูปที่ 4 ตัวอย่างความแปรปรวนทั่วไป

Option Strict On

แบบฟอร์มชั้นเรียนสาธารณะ1

Sub Form1_Load() จัดการ MyBase.Load

ปุ่มหรี่แสงเป็นรายการใหม่ (ของปุ่ม) จาก

-

ปุ่มใหม่ด้วย

-

.ชื่อ = btnOk,

.เปิดใช้งาน = จริง

-

ปุ่มใหม่ด้วย

-

.Name = btnยกเลิก

.เปิดใช้งาน = เท็จ

-

-

Dim EnabledOnly = FilterEnabledOnly (ปุ่ม)

จบหมวดย่อย

ฟังก์ชั่น FilterEnabledOnly(

ByVal ควบคุมเป็น IEnumerable (ของการควบคุม)

) เป็น IEnumerable (ของการควบคุม)

กลับจาก c ในการควบคุม

โดยที่ c.Enabled = True

ฟังก์ชันสิ้นสุด

จบคลาส

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

Delegate Function Func(Of In T, Out R)(ByVal param As T) As R

คุณสามารถใช้ตัวแก้ไข In และ Out บนอินเทอร์เฟซและผู้รับมอบสิทธิ์แบบกำหนดเองได้ อินเทอร์เฟซและผู้รับมอบสิทธิ์ทั่วไปจำนวนมากใน .NET Framework 4 ถูกทำเครื่องหมายเป็นตัวแปร ตัวอย่างทั่วไป ได้แก่ ผู้รับมอบสิทธิ์ Action/Func ทั้งหมด, IEnumerable(Of T), IComparer(Of T), IQueryable(Of T) ฯลฯ

สิ่งที่ยอดเยี่ยมเกี่ยวกับความแปรปรวนทั่วไปก็คือมันเป็นคุณสมบัติที่คุณไม่ต้องกังวลเลย ถ้ามันทำงานได้ดี คุณจะไม่มีวันสังเกตเห็นเลย สถานการณ์ที่ครั้งหนึ่งเคยส่งผลให้เกิดข้อผิดพลาดของคอมไพเลอร์หรือจำเป็นต้องเรียก .Cast(Of T) ทำงานได้ดีใน Visual Basic 2010

ปรับปรุงพารามิเตอร์ทางเลือก

พารามิเตอร์เสริมมีคุณลักษณะที่มีประสิทธิภาพที่เป็นประโยชน์ ซึ่งช่วยให้นักพัฒนาสามารถสร้างวิธีการที่ยืดหยุ่นมากขึ้น และหลีกเลี่ยงไม่ให้คลาสมีเมธอดโอเวอร์โหลดมากเกินไป ในอดีต มีข้อจำกัดเล็กน้อยว่าพารามิเตอร์เสริมต้องไม่เป็นค่าว่าง (หรือแม้กระทั่งประเภทโครงสร้างที่ไม่ใช่ภายใน) Visual Basic 2010 ช่วยให้คุณสามารถกำหนดพารามิเตอร์ทางเลือกของค่าประเภทใดก็ได้:

Sub DisplayOrder(ByVal customer As Customer,

ByVal orderID เป็นจำนวนเต็ม

หน่วย ByVal เสริมเป็นจำนวนเต็ม?

ตัวเลือกพื้นหลัง ByVal สีเป็นสี = ไม่มีเลย)

จบหมวดย่อย

ในตัวอย่างนี้ หน่วยเป็นประเภท Nullable(Of Integer) และ backgroundColor เป็นประเภทโครงสร้างที่ไม่ใช่เนื้อหา แต่ยังคงใช้เป็นพารามิเตอร์ทางเลือก Visual Basic 2010 ยังให้การสนับสนุนที่ดีกว่าสำหรับพารามิเตอร์เสริมทั่วไป

ประเภทการทำงานร่วมกันแบบฝัง

จุดอ่อนทั่วไปสำหรับแอปพลิเคชันที่ดำเนินการ COM interop คือความจำเป็นในการใช้ Primary Interop Assembly (PIA) PIA คือชุดประกอบ .NET ที่ทำหน้าที่เป็น runtime callable wrapper (RCW) บนคอมโพเนนต์ COM และมี GUID เฉพาะที่ระบุ แอสเซมบลี .NET จะสื่อสารกับ PIA ซึ่งจะดำเนินการจัดเรียงข้อมูลที่จำเป็นเพื่อย้ายข้อมูลระหว่าง COM และ .NET

น่าเสียดายที่ PIA อาจทำให้การปรับใช้ยุ่งยากเนื่องจากเป็น DLL เพิ่มเติมที่จำเป็นต้องนำไปใช้กับคอมพิวเตอร์ของผู้ใช้ปลายทาง นอกจากนี้ยังอาจทำให้เกิดปัญหาด้านเวอร์ชันได้ ตัวอย่างเช่น หากคุณต้องการให้แอปพลิเคชันของคุณทำงานกับทั้ง Excel 2003 และ Excel 2007 คุณจะต้องปรับใช้ PIA ทั้งสองกับแอปพลิเคชันของคุณ

คุณลักษณะประเภทการทำงานร่วมกันแบบฝังจะฝังลงในแอปพลิเคชันโดยตรง แต่จะมีเพียงประเภทและสมาชิกจาก PIA เท่านั้นที่จำเป็นอย่างยิ่ง ดังนั้นจึงไม่จำเป็นต้องปรับใช้ PIA กับคอมพิวเตอร์ของผู้ใช้ปลายทาง

หากต้องการเปิดใช้งานคุณสมบัตินี้สำหรับออบเจ็กต์ที่มีอยู่ (ซึ่งเปิดใช้งานตามค่าเริ่มต้นสำหรับการอ้างอิงใหม่) ให้เลือกการอ้างอิงใน Solution Explorer และเปลี่ยนตัวเลือก Embed Interop Types ในหน้าต่างคุณสมบัติ (ดูรูปที่ 5) หรืออีกทางหนึ่ง หากคอมไพล์ด้วยคอมไพเลอร์บรรทัดคำสั่ง ming ให้ใช้สวิตช์ /l (หรือ /link) แทน /r และ /reference

รูปที่ 5 การเปิดใช้งานประเภทการทำงานร่วมกันแบบฝังใน Solution Explorer

หลังจากเปิดใช้งานคุณสมบัตินี้ แอปพลิเคชันจะไม่พึ่งพา PIA อีกต่อไป หากคุณเปิดชุดประกอบใน Reflector หรือ ildasm คุณจะสังเกตเห็นว่าจริงๆ แล้วไม่มีการอ้างอิงถึง PIA เลย

หลายเป้าหมาย

ส่วนที่ดีที่สุดเกี่ยวกับคุณสมบัติทั้งหมดใน Visual Basic 2010 ก็คือ คุณสามารถใช้ได้แม้ในโครงการที่กำหนดเป้าหมายเป็น .NET Framework 2.0 ถึง .NET Framework 3.5 ซึ่งหมายความว่าคุณลักษณะต่างๆ เช่น อักขระต่อเนื่องของบรรทัดโดยนัย ตัวอักษรอาร์เรย์ ตัวเริ่มต้นคอลเลกชัน คำสั่ง lambda คุณสมบัติที่นำไปใช้โดยอัตโนมัติ ฯลฯ ทั้งหมดจะพร้อมใช้งานในโครงการที่มีอยู่โดยไม่ต้องกำหนดเป้าหมาย .NET Framework 4 ใหม่

ข้อยกเว้นคือประเภทการทำงานร่วมกันแบบฝังซึ่งขึ้นอยู่กับประเภทที่มีอยู่ใน .NET Framework 4 เท่านั้น ดังนั้น หากคุณกำหนดเป้าหมาย .NET Framework เวอร์ชัน 2.0 ถึง 3.5 คุณจะไม่สามารถใช้คุณลักษณะนี้ได้ นอกจากนี้ ประเภทที่ทำเครื่องหมายเป็นตัวแปรจะถูกทำเครื่องหมายเหมือนกับที่อยู่ใน .NET Framework 4 เท่านั้น ดังนั้นในตัวอย่างก่อนหน้านี้ หากคุณกำหนดเป้าหมายเวอร์ชัน 2.0 ถึง 3.5 คุณยังคงต้องเรียก .Cast(Of T) อย่างไรก็ตาม หากคุณกำหนดเป้าหมายเวอร์ชันก่อนหน้าเหล่านี้ คุณสามารถสร้างประเภทตัวแปรของคุณเองได้ (โดยใช้ตัวแก้ไข In/Out)

หากต้องการเปลี่ยนกรอบงานเป้าหมายปัจจุบันของแอปพลิเคชันของคุณ ให้ดับเบิลคลิก My Projects คลิกแท็บ Compile คลิก Advanced Compilation Options จากนั้นเลือกจากกล่องคำสั่งผสมที่ด้านล่าง

จริงๆ แล้วไม่มีการสลับบรรทัดคำสั่ง ming เพื่อเปิดใช้งานคุณสมบัตินี้เมื่อรวบรวมจากบรรทัดคำสั่ง ming คอมไพลเลอร์จะดูว่าแอสเซมบลีใดที่ให้คำจำกัดความของ System.Object (โดยปกติคือ mscorlib) และเฟรมเวิร์กใดที่แอสเซมบลีกำหนดเป้าหมาย จากนั้นจึงทำเครื่องหมายค่านั้นในแอสเซมบลีเอาต์พุต (คอมไพเลอร์ใช้กลไกเดียวกันนี้ในการสร้างแอสเซมบลีของ Silverlight) เมื่อใช้ IDE ทั้งหมดนี้จะเกิดขึ้นอย่างโปร่งใส ดังนั้นคุณจึงไม่ต้องกังวลอะไร

ยินดีให้ลองครับ

อย่างที่คุณเห็น Visual Basic 2010 มีคุณสมบัติที่มีประสิทธิภาพมากมายที่ช่วยให้คุณทำงานได้อย่างมีประสิทธิภาพมากขึ้นในขณะที่เขียนโค้ดน้อยลง และปล่อยให้คอมไพเลอร์ทำงานได้มากขึ้น ในบทความนี้ ฉันได้กล่าวถึงเฉพาะคุณลักษณะของภาษาเท่านั้น แต่มีการปรับปรุงที่ยอดเยี่ยมมากมายใน Visual Basic 2010 IDE การปรับปรุงบางอย่างมีดังต่อไปนี้:

นำทางไปยัง

เน้นคำพูด

ที่เกิดจากการใช้งาน

Better IntelliSense (การจับคู่สตริงย่อย การค้นหาแบบ Camelcase รูปแบบข้อเสนอแนะ – มีประโยชน์สำหรับการทดสอบสไตล์การพัฒนาของคุณก่อน)

รองรับหลายจอภาพ

ซูม

ทีม Visual Basic กระตือรือร้นที่จะรับฟังคำติชมของคุณเกี่ยวกับความพยายามของเราในการปรับปรุง Visual Basic ดังนั้นโปรดส่งข้อคิดเห็นและคำถามของคุณบน Microsoft Connect ถึงเรา หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับภาษาและคุณลักษณะ IDE โปรดดูเนื้อหาที่ msdn.com/vbasic ซึ่งรวมถึงบทความ ตัวอย่าง และวิดีโอแสดงวิธีการ แน่นอนว่าวิธีที่ดีที่สุดในการเรียนรู้คือการเจาะลึกและใช้ผลิตภัณฑ์ ดังนั้นจึงถึงเวลาติดตั้งและทดลองใช้งาน