Visual Studio 2010 ve .NET Framework 4.0 CTP'lerinin yayınlandığı bugünlerde
iki yol sonra karşımıza çıkacak yazılım teknolojilerine yön verme ve inceleme
adına heyecanlı günler yaşadığımı itiraf edebilirim.
Visual Studio 2008 ve .NET Framework 4.0 yeni logoları.
Tüm bu yenilikler arasında tabi ki Visual Basic'in de artık 10'uncu sürümü
ile karşı karşıyayız. Bu yazıa şu an yayında olan CTP üzerinden yola çıkarak VB
10 ile beraber gelen yenilikleri inceleyeceğiz.
Statement Lambda
Lambda'lara az çok LINQ ile beraber alışmıştık. VB 10 ile beraber çok ilginç
ve bir o kadar da güzel bir özellik geliyor. Ama gelin bunun öncesinde VB 9 ile
neler yapardık bir göz atalım.
[VB9]
Public Class Form1
Private Sub Form1_Click(ByVal sender As Object, ByVal e As System.EventArgs)
MsgBox("Burada")
End Sub
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
AddHandler Me.Click, AddressOf Form1_Click
End Sub
End Class
Gördüğünüz gibi basit bir şekilde Form'un Load durumunda
dinamik olarak yine formun Click event'ını bir
Sub'a bağlıyoruz. Böylece artık forma tıklandığında "Burada"
mesajı gösterilecek. Tüm bunu yapmak için, yani dinamik event
bağlamak için gidip ayrı bir yerde Sub yazmamız ve sonra da
AddressOf ile bağlamamız gerekiyordu. Oysa artık satır için
Sub var :)
[VB10]
Public Class Form1
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
AddHandler Me.Click, Sub()
MsgBox("Burada")
End Sub
End Sub
End Class
Nasıl? Güzel değil mi? Satır içi Sub'ımızı yazdık bitti. Bu işlevselliği
AddressOf'u kullandığınız her yerde kullanabileceğinizi
düşünürseniz gerçekten süper! Peki ya Function'lar? İşte size satır içi Function
kullanımı.
[VB10]
Dim Fonksyon = Function(x As Integer)
Return x * 2
End Function
MsgBox(Fonksyon(2))
Yukarıdaki kod içerisinde doğrudan Function'ımızı kodun içinde satır içi
yazarak tanımlıyoruz ve sonrasında da rahatlıkla Invoke işlemini
gerçekleştirebiliyoruz.
Coşmuş Type Inference
Type Inference'a zaten alışkın durumdayız. VB10 ve VS10 ile beraber bir adım
daha ileriye gidiliyor. Örneğin aşağıdaki gibi bir değişken tanımında değişkenin
bir Array olduğunu veya ne Array'i olduğunu belirtmenize gerek kalmıyor.
Type Inference'ın bu kadarı :)
Unutmayın bu şekilde tanımlamalar performans kaybına neden olmaz. Compiler
Compile Time'da gerekli kodları üretecektir.
PLINQ
Parallel LINQ aslında VB'ye özel bir konu değil fakat VS10 ve VB10 ile
beraber de geldiği için hızlıca bahsetmek istiyorum. Adından da anlaşılacağı
üzere PLINQ'de çalıştırılan sorguların kendi içlerinde birden çok işlemcide
çalıştırılmak üzere hazırlanmış durumdalar. Gelin hemen aşağıdaki koda bir göz
atalım.
[VB10]
Dim sayilar = {10, 20, 30, 40}
Dim XML = <Sayilar>
<%= From Inc In sayilar.AsParallel
Select <Sayi><%= Inc %></Sayi> %>
</Sayilar>
AsParallel metodu otomatik olarak PLINQ kullanılmasını
sağlıyor. Normal şartlarda sırası ile 10, 20, 30, 40 sayılarını alırken bu
şekilde AsParallel olarak sorgumuzu çalıştırdığımızda 20, 10,
30, 40 gibi bir sonuç elde ediyoruz. Bunun nedeni işlemin paralel bir şekilde
çalıştırıldıktan sonra sonucun bize döndürülüyor olması. Bu ufak detay bile
aslında PLINQ'in kullanılabileceği ve kullanılamayacağı noktalara karar vermek
için yeterli sayılabilir.
Add
metodunu defalarca kullanmaktan kurtulunu!
Bu özelliğe başlık bulmakta zorlandığımı sanırım farkına vardınız.
Düşünün ki elimizde bir List var ve bu List
içerisinde birden çok Item eklememiz gerekiyor. Normal
şartlarda her bir Item'ı yaratarak tek tek Add
metodunu çağırırdık.
[VB9]
Dim Liste As New List(Of String)
Liste.Add("Ahmet")
Liste.Add("Mehmet")
Peki VB10 tarafında neler yapabiliriz? Yeni bir Keyword'ümüz var :
From
[VB10]
Dim Liste As New List(Of String) From {"Ahmet", "Mehmet"}
Aslında arka planda çalışan yapı doğrudan dizi içerisindeki bir
Item için Add metodunu çağırmaktan farklı değil.
Örneğin elimizde özel bir sınıfın listesi olsaydı aynı şekilde o sınıftan da
objeler yaratarak from ile listeye ekleyebilirdik.
[VB10]
Dim Liste As New List(Of Adam) From {
New Adam() With {.Adi = "Ahmet", .Soyadi = "Hebe"},
New Adam() With {.Adi = "Mehmet", .Soyadi = "Hebe"}}
Örnek kodumuzdaki List bir Adam
List'i olduğu için burada önemli olan List sınıfının
Add metodunun Adam tipinden değişken istiyor
olması. Sırasıyla yaratarak bir array olarak veriyoruz. İsterseniz Adam
tipinden List'elerin Add metoduna
Overrides keywordü ile bir alternatif eklemek için
ExtensionMethod'ları da kullanabilirsiniz.
[VB9]
Module Module1
<Runtime.CompilerServices.Extension()>
Sub Add(ByVal x As List(Of Form1.Adam), ByVal Adi As String, ByVal soyadi As String)
x.Add(New Form1.Adam() With {.Adi = Adi, .Soyadi = soyadi})
End Sub
End Module
VB9'da tanıştığımız Extension Method'lardan bir adet tanımlayarak
Adam tipinden bir Liste oluşturulduğunda bu objelerin
bir Add metodlarının olacağını ve Adi,
Soyadi olarak String'ler alacağını tanımlıyoruz.
Extension Method içerisinde de bu bilgileri alıp yeni bir Adam
yaratıp listeye ekliyoruz. Böylece artık elimizdeki listeye Adam
eklemek için Add metodunu çağırırken iki adet String verip bir
Adam eklenmesini de sağlayabildik. Ama aslında bu Add
metodunu da biz değil From keyword'ü kullanacak.
[VB10]
Dim Liste As New List(Of Adam) From {
{"Ahmet", "Hebe"},
{"Mehmet", "Hebe"}}
Böylece artık yukarıdaki kodumuzda doğrudan bilgileri vererek her seferinde
New ile obje yaratmadan da istediğimiz kadar Adam
ekleyebiliriz.
Property tanımlamaları
C#'dan en çok kıskandığım özelliklerden biri Get ve
Set'lerin kısaltılmasıydı. Çoğu zaman Property
tanımlarken aslında Get ve Set kodlarını değiştirmiyoruz. Her ne kadar VS
içerisinde kısa yolları kullanarak bu kodları yazmıyor olsak da maalesef biz
yazmamış olsak da projemizdeki her satır kodun bir gün bir bug olarak karşımıza
çıkma ihtimali var :)
[VB9]
Private PAdi As String = "Varsayılan"
Public Property Adi() As String
Get
Return PAdi
End Get
Set(ByVal value As String)
PAdi = value
End Set
End Property
"Eskiden" kelimesini kullanmak için daha erken olsa da maalesef Property'leri
VB9'da yukarıdaki şekilde tanımlıyorduk.
[VB10]
Public Property Adi As String = "Varsayılan"
Sanırım bu kodun üzerine daha fazla söz söylemeye gerek yok.
Son sürpriz!
Yukarıdaki kodlar dikkatinizi çekmediyse ufak bir ipucunda buluniyim. Tek
satırda yazılması gereken kodları çoklu satırlı olarak yazarken bir değişiklik
görebiliyor musunuz?
[VB9]
Dim Liste2 As New List(Of Adam) From { _
{"Ahmet", "Hebe"}, _
{"Mehmet", "Hebe"}}
[VB10]
Dim Liste As New List(Of Adam) From {
{"Ahmet", "Hebe"},
{"Mehmet", "Hebe"}}
Benim sanırım en çok sevindiğim gelişmelerden biri bu oldu. Artık uzun uzun
tek satırda kod yazmak zorunda değiliz veya her satır atlamak istediğimizde _
alt çizgi ile alt satıra geçme zorunluluğu da yok! C#'dan en çok kıskandığım
özelliklerden biri de buydu.
VB kolayın kullanımını arttırarak kuvvetli bir dil olarak var olma yolunda
tam gaz devam ediyor. Gelişmeler çok sevindirici. Bakalım 2010'a kadar karşımıza
çıkacak diğer CTP'lerde neler olacak.
Hepinize kolay gelsin.