sok’s page

www.itpk.info

Nowości w C# 3.0
dateOctober 22, 2007
postedbyPosted by soczek

Jeszcze nie zdążyliśmy nacieszyć sie C# 2.0 a tu już mamy dostępną wersję C# 3.0. Nowa wersja zawarta jest w Visual Studio 2008. W tej wersji Microsoft wprowadził wiele nowych elementów do składni, które ułatwiają pisanie aplikacji oraz poprawił to co było niedopracowane lub po prostu nie udane w poprzedniej wersji. Po krótce opiszę najważniejsze z nich.

Zmienne domniemane

Polegają na zwalnianiu programisty od podania typu danej zmiennej podczas pisania aplikacji. Zatem typ zmiennej definiowany jest przez typ danej jakim zainicjujemy zmienną. Może to być typ prosty lub tablica.
Klasyczna inicjacja:

int x = 8;
double y = 4.2;
string s = ”zmienna”;
float [] tab = new float[]{1.4, 7.2, 5.7};

Nowy sposób inicjacji:

var x = 8;
var y = 4.2;
var s = ”zmienna”;
var tab = new float[]{1.4, 7.2, 5.7};

Co nam to daje? Przede wszystkim uproszczenie deklarowania zmiennych oraz przejrzystość programu. Jednak należy zwrócić uwagę na to iż na zmienne deklarowane przez słowo var nałożone jest pewne ograniczenie - definicja takiej zmiennej wymaga inicjalizacji. Nie można stosować konstrukcji:

var x;

ponieważ kompilator musi wiedzieć jakie dane przechowywać będzie dana zmienna.

Rozszerzenie typów bez dziedziczenia

Co nam to daje? Np. dodanie nowych metod do klas takich jak string czy int. Aby tak było można zrobić konieczne jest aby metoda była statyczna, statycznej klasy, oraz pierwszy z parametrów metody musi być poprzedzony słowem this jeśli jest typu takiego jak klasa.
Przykład:

public static int ToInt32(this string s)
{
return Convert.ToInt32(s) ;
}

Metoda ta poszerza możliwości typu string o nową metodę ToInt32. Dzięki tej metodzie można użyć kod:

string s = “3″;
int i = s.ToInt32();

Tym sposobem rozszerzyliśmy klasę string bez jawnego dziedziczenia z niej, co wcześniej było niewykonalne.

Inicjalizatory

Inicjalizator to mechanizm, który pozwala podawać wartości pól i właściwości nowo tworzonego obiektu/kolekcji/tablic przy wywołaniu konstruktora.
Wyróżniamy inicjalizatory:

  • obiektów

    • Przykład:

    public class CoOrdinate
    {
    public int x ;
    public int y;
    }

    Dzieki inicjalizatorowi możemy nowo tworzonemu obiektowi nadać wartości pól i właściwości:

    var myCoOrd = new CoOrdinate{ x = 0, y= 0} ;

  • kolekcji

    • Przykład:

    List animals = new List();
    animals.Add(”monkey”);
    animals.Add(”donkey”);
    animals.Add(”cow”);
    animals.Add(”dog”);
    animals.Add(”cat”);

    Podobnie możemy uczynić z kolekcjami, i zamienić:

    List animals = new List {
    “monkey”, “donkey”, “cow”, “dog”, “cat” } ;

  • tablic

    • Przykład:

    public class CoOrdinate
    var a = new[] { 1, 10, 100, 1000 }; // int[]
    var b = new[] { 1, 1.5, 2, 2.5 }; // double[]
    var c = new[] { “hello”, null, “world” }; // string[]

LINQ - Language integrated query

To mechanizm pozwający na użycie definicji znanych z języka SQL do manipulowania danymi w samym kodzie C#. Czyli użycie składni DML (Data Manipulation Language)na obiektach w C# takich jak tablice, bazy SQL, typy generyczne czy dane poprane z XML.
Przykład:

public void Linq()
{
int[] liczby = { 6, 2, 6, 1, 2, 9, 3, 0, 8, 4 };

var malaLiczba =
from l in liczby
where l < 5
select l;

Console.WriteLine(”liczby < 5:”);
foreach (var x in malaLiczba) {
Console.WriteLine(x);
}
}

Przykład pokazuje użycie LINQ. Z tablicy liczby wybieramy liczby mniejsze od 5. Z przykładu widać, że takie zastosowanie jest logiczniejsze i bardziej estetyczne w kodzie. Funkcja ta bardzo ułatwi operację na danych.

Wyrażenie Lambda

Kto by pomyślał, że najnowsza wersji 3.0 będzie zawierać wyrażenie Lambda. System ten składa się z jednego przekształcenia: zamiany zmiennych. Wyrażenia Lambda jak każdy chyba pamięta mają tę własność, że wszystkie dające się obliczyć funkcje mogą być zapisane przy ich użyciu.
Przykład:

class Program
{
delegate void DemoDelegate();
static void Main(string[] args)
{
DemoDelegate myDelegate = () => Console.WriteLine(”Pierwsza metoda”) ;
myDelegate();

myDelegate = () => Console.WriteLine(”Druga metoda”) ;
myDelegate();
}
}

Z przykładu widać, że jest możliwość na jeszcze łatwiejsze użycie delegatów.

Podsumowanie

Jak widać nowa wersja C# 3.0 ma wiele możliwości a te wypisane wyżej to tylko początek. Miejmy nadzieję, że wszystkie dotychczas wprowadzone zmiany oraz nowości idą w dobrą stronę. Nam programistom pozostało testować nowe funkcje no i czekać na wersję 4.0 ;)

Źródła:
http://download.microsoft.com/download/9/5/0/9503e33e-fde6-4aed-b5d0-ffe749822f1b/csharp%203.0%20specification.doc
http://www.microsoft.com/emea/msdnshowtime/sessionh.aspx?videoid=319


Leave a Reply

comments