thexpot.net

C# 3.0 da kod yazımını kolaylaştırmak için bir çok yeni özellik eklenecek. Özellikle iyi bir IDE kullanmayan yazılımcıların ağzını sulandırabilecek bu özelliklerden en çarpıcı olanı bence Lamda ve Sorgu İfadeleri (SQL & XQuery)

Özelliklerin bir kısmı söyle belirtilmiş Microsoft tarafından:

Implicitly typed local variables (Kapalı tipli yerel değişkenler)

Bir değişkene atadığınız değerin ya da yapının tipinin belli olduğu durumlarda değişkenin tipini ayrıca belirtmenize gerek kalmayacak:

var i = 5;
var s = "Hello";
var d = 1.0;
var numbers = new int[] {1, 2, 3};
var orders = new Dictionary();

Yukarıdaki kod aşağıdaki ile tamamen aynıdır

int i = 5;
string s = "Hello";
double d = 1.0;
int[] numbers = new int[] {1, 2, 3};
Dictionary orders = new Dictionary();

Bu özellik sayesinde, foreach döngüsü de şu şekilde kullanılabilir::

int[] numbers = { 1, 3, 5, 7, 9 };
foreach (var n in numbers) Console.WriteLine(n);

foreach için de ayrıca tipi tanımlamanıza gerek yok nasıl olsa numbers hep int’lerden oluşuyor.

Extension methods (Genişletme metodları)

Delphi Dot Net’teki Helper Class’larla aynı kapıya çıkan yapılar. Yeni bir metod eklemek istediğiniz sınıfı değiştirmeden yazdığınız başka bir sınıfla yeni metodlar eklemenize olanak sağlıyor. Delphi’deki uyarı bunun içinde geçerli: Sadece çok mecbur kaldığınızda kullanın. Asla bir tasarım öğesi olarak kullanmayın

Aşağıdaki örnek int[] tipine Slice adında bir metod ekliyor

namespace Acme.Utilities
{
    public static class Extensions
    {
        public static T[] Slice(this T[] source, int index, int count) {
            if (index < 0 || count < 0 || source.Length – index < count)
                throw new ArgumentException();
            T[] result = new T[count];
            Array.Copy(source, index, result, 0, count);
            return result;
        }
    }
}

int[] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] a = digits.Slice(4, 3); // Extensions.Slice(digits, 4, 3) ile aynı işi yapar

Lambda Expressions (Lambda İfadeleri)

Efendim, Phytonla hiç alakam olmadı ama duyduğuma göre phytonda fonksiyon döndüren lambda diye bir keyword varmış.

C# 3.0 bahsedilen Lambda ifadelerde bunun gibi bir iş yapıyor. Aslında bu az çok C++ macrolarına da benziyor ama çok daha gelişmiş bir şekli tabiî ki. İster tip belirterek, ister belirtmeden generic fonksiyon gövdesi yazıyorsunuz. Tabi böyle yazılmış bir kodun okunabilirliği ne derece olur onu bilmiyorum ama esneklik bakımından çok şey katacağı kesin.

class ItemList: List
{
    public int Sum(Func<T,int> selector) {
        int sum = 0;
        foreach (T item in this) sum += selector(item);
        return sum;
    }
    public double Sum(Func<T,int> selector) {
        double sum = 0;
        foreach (T item in this) sum += selector(item);
        return sum;
    }
}

Yukarıda ItemList adıyla bir sınıf tanımlanmış ve iki tane Sum metodu var. Sum metodu tüm Itemları parametre geçilen bir selector fonksiyonuna göre topluyor. Burada toplama işlemi için gerekli fonksiyonu da geçebildiğinize dikkat çekerim. Kullanımı da şöyle örneklenmiş:

class Detail
{
    public int UnitCount;
    public double UnitPrice;
    ...
}
void ComputeSums() {
    ItemList orderDetails = GetOrderDetails(...);
    int totalUnits = orderDetails.Sum(d => d.UnitCount);
    double orderTotal = orderDetails.Sum(d => d.UnitPrice * d.UnitCount);
    ...
}

İlk toplam için sadece birim toplamını döndüren bir fonksiyon, ikinci toplam için birim fiyatının karesini döndüren bir fonksiyon geçilmiş oluyor. Dolayısıyla ilk toplam tüm item’ların birim toplamı olurken ikinci toplam ise tüm item’ların birim fiyatlarının kareleri toplamı oluyor.

Object and collection initializers (Nesne ve Koleksiyon Başlatıcıları)

Bu özellikte yine programcıyı kod kalabalığından kurtarmak ve okunabilirliği arttırmak için eklenmiş zannımca:

public class Point
{
    int x, y;
    public int X { get { return x; } set { x = value; } }
    public int Y { get { return y; } set { y = value; } }
}

Yukarı da bir Nokta sınıfı tanımlanmış ve X,Y adıyla iki tane propertysi mevcut. Public olarak tanımlandıkları için erişip değiştirmemiz mümkün. Bunu şöyle yapabiliriz

Point p = new Point();
p.X = 4;
p.Y = 5;

ya da c# 3.0′da şöyle yapabiliriz:

var p = new Point {X=4,Y=5};

İkinci bir örnek ise şöyle verilebilir:

public class Contact
{
    string name;
    List phoneNumbers = new List();
    public string Name { get { return name; } set { name = value; } }
    public List PhoneNumbers { get { return phoneNumbers; } }
}
var contacts = new List {
    new Contact {
        Name = "Chris Smith",
        PhoneNumbers = { "206-555-0101", "425-882-8080" }
    },
    new Contact {
        Name = "Bob Harris",
        PhoneNumbers = { "650-555-0199" }
    }
};

Yukarıdaki kodu aslen şöyle yazmalıydık:

var contacts = new List();
var <strong>c1 = new Contact();
__c1.Name = "Chris Smith";
__c1.PhoneNumbers.Add("206-555-0101");
__c1.PhoneNumbers.Add("425-882-8080");
contacts.Add(</strong>c1);
var <strong>c2 = new Contact();
__c2.Name = "Bob Harris";
__c2.PhoneNumbers.Add("650-555-0199");
contacts.Add(</strong>c2);

Query Expressions (Sorgu İfadeleri)

Koleksiyonlarda, arraylerde Hibernate’in HQL’sine benzer sorgular yazarak çalışabiliyoruz. Aslında bu C Omega ve LinQ karışımı bir şey olmuş. Sorgu ifadesi from kelimesiyle başlayıp select kelimesiyle sonlanıyor. Gruplama, süzme gibi işlemleri de belirtebiliyorsunuz.

from c in customers
where c.City == "London"
select c.Name

Bu sorgu şu kodu yazmakla aynı :

customers.
Where(c => c.City == "London").
Select(c => c.Name)

Doküman çokça yazım kuralı ve sorguların nasıl işleneceği üzerine odaklanmış. Hala geliştirilmekte olduğundan pek bir örnek mevcut değil şu an. İştah kabartıcı olduğu kesin!