Nowa wersja C# Autor: Piotr Sobczak Seminarium magisterskie „Zagadnienia programowania obiektowego” Wydział Matematyki, Informatyki i Mechaniki Uniwersytet Warszawski

PLAN- podstawy: Wprowadzenie Przestrzenie nazw Typy, parametry, konwersje Klasy Instrukcje sterujące Właściwości Interfejsy, operatory is i as Wyjątki Delegaty

PLAN – rozszerzenia w C# 2.0: Typ generyczny Metody anonimowe Typ dzielony Typ „nullable” Podsumowanie i wnioski

Wprowadzenie Główny architekt – Anders Hejlsberg Język zorientowany-obiektowo, powstały na bazie C++ i Java Pierwszy język programowania komponentowego z rodziny C/C++ Obsługuje: klasy, interfejsy, struktury Główny architekt – Anders Hejlsberg

Klasy Definicja klasy jest połączona z deklaracją – nie ma osobnych plików .h/.cpp, jak w przypadku C++ Przykład: public class HelloWorld { public static void Main() System.Console.WriteLine(”Witamy w .NET”); }

Klasy – modyfikatory dostępu Modyfikatory występują przed deklaracjami klas, metod, atrybutów. public brak ograniczeń private dostęp tylko z wewnątrz klasy protected dostęp z wewnątrz klasy oraz z klas dziedziczących internal dostęp z klas z tego samego pakietu protected internal = protected OR internal

Klasy z atrybutem sealed Jeżeli deklaracja klasy zawiera atrybut sealed, to nie jest możliwe jej dziedziczenie sealed public class MojaKlasa { }

Tworzenie obiektów Tak samo jak w C++ Button b = new Button();

Klasa object Wszystkie klasy dziedziczą po object Zamiana na object może być niejawna, lecz w drugą stronę wymagane jest jawne rzutowanie int i = 10; object obj = i; int j = (int) obj;

Konwersje między typami niejawne (dopuszczalne, gdy nie ma straty) short x = 5; int y = x; // int ma 32bity, a short 16, wiec ok. jawne (wymagane przy możliwości straty) int x = 500; short y = (short) x; // bez wymuszenia się nie skompiluje

Przestrzenie nazw (namespaces) Zapobiegają występowaniu konfliktów w nazwach klas Grupują klasy o podobnym zastosowaniu Separatorem jest ‘.’ (znak kropki) System.Console.WriteLine(”Tralalala”); System.Windows.Forms.Button b = new System.Windows.Forms.Button();

namespace - deklarowanie namespace Nazwa { namespace NazwaWewnetrzna class PrzykladowaKlasa … } Odwołanie z zewnątrz: Nazwa.NazwaWewnetrzna.PrzykladowaKlasa

Słowo kluczowe using using System; … Console.WriteLine(”Witamy w .NET”); UWAGA! Po using nie podajemy nazwy klasy, tylko namespace using System.Console; … WriteLine(”Witamy .NET”);

System typów Wspólny system typów (Common Type System) Typy użytkownika Typ wyliczeniowy Struktury

Typy proste i typy referencyjne Pamiętają bezpośrednio dane Każdy zawiera oddzielną kopię danych Operacje na jednej zmiennej nie mają wpływu na inne Typy referencyjne Pamiętają referencję na pamiętane dane Dwie zmienne mogą wskazywać na tą samą daną Operacje na jednej zmiennej mogą mieć wpływ na inne

Typy proste wbudowane 8-bitowe: byte, char, sbyte 16-bitowe: short, ushort 32-bitowe: int, uint, float 64-bitowe:double, decimal, long, ulong int liczba == System.Int32 liczba long liczba == System.Int64 liczba

Tworzenie typów użytkownika Typ wyliczeniowy definiowanie enum Kolor{Czerwony,Zielony,Niebieski}; sposób użycia Kolor kolor1 = Kolor.Czerwony;

Tworzenie typów użytkownika cd.. Struktury definiowanie struct Osoba { public string Imie, Nazwisko; public int Wiek; } sposób użycia Osoba pracownik; pracownik.Imie = "Jan"; pracownik.Wiek = 30;

Przekazywanie parametrów 1/2 Przez wartość przekazywane są przedstawione typy wbudowane oraz: enum, struct Pozostałe typy przekazywane są przez referencję.

Przekazywanie parametrów (2/2) Typ podstawowy można przekazywać przez referencję wykorzystując słówko pomocnicze ref public void Inkrementuj(ref int liczba) { liczba++; } W wywołaniu metody także używamy ref: Inkrementuj(ref liczba);

Dziedziczenie Przykład: class rodzic { virtual public void dajkasę() {...} } class dziecko: rodzic { override public void dajkasę() {...} NIE jest dopuszczalne dziedziczenie wielokrotne Rozwiązanie poprzez implementację Interfejsów

if…else Identyczna składnia, jak w C++ / Java Warunek musi być typu bool (nie może być int, jak w C++) Unikamy więc błędów typu: if (zmienna = 5)

switch (1/2) Nie jest dopuszczalny automatyczny przeskok do kolejnego przypadku case 0: ZrobCos(); break; case 1: poza sytuacją, gdy case jest „pusty” Bez tego program się nie skompiluje

switch (2/2) Skok do innego przypadku musi być jawny case 0: ZrobCos(); goto case 1; case 1: Wyrażenie może być string-iem (w C++ wymagany był int) switch (nazwisko) { case „Kowalski”: break; case „Nowak”: ZrobCosInnego(); }

while, do…while while (i < 10) { Console.WriteLine(„Wartość {0}”, i); } do } while (i < 10);

for – zakres zmiennych Zmienne zadeklarowane w pętli for obowiązują jedynie wewnątrz pętli (tak jak w Javie; w C++ zależało to od wersji języka) for (int i = 0; i < 10; i++) { … } for (int i = 5; i < 20; i++)

Foreach foreach (string nazwa in wszystkieNazwy) { Console.WriteLine(nazwa); } Wymagane: wszystkieNazwy musi realizować interfejs IEnumerable

Tablice a „params” Pozwala tworzyć metody z nieokreśloną liczbą argumentów public int Sumuj(params int[] skladniki) { int suma = 0; foreach (int skladnik in skladniki) suma += skladnik; } return suma; Sumuj (1, 2, 3, 4); == 10 Sumuj (5, 6); == 11 Sumuj (); == 0

Właściwości/własności Class Test Użycie: { Test pom=new Test(); private int liczba; int x =pom.Liczba; public int Liczba pom.Liczba=1; { get { return liczba; } set liczba = value; if (liczba < 0) liczba = 0;

Implementacja interfejsów interface ITestable { bool TestMe(); } public class MojaKlasa : ITestable bool TestMe() …

Operator IS is służy do sprawdzenia, czy obiekt można rzutować na wybrany typ bez rzucania wyjątków object obiekt = new MojaKlasa(); if (obiekt is MojaKlasa) { ((MojaKlasa)obiekt).Zagraj(); } Możemy też sprawdzać, czy obiekt implementuje wybrany interfejs: if (obiekt is ITestable)

Operator as Łączy is z operatorem rzutowania. Jeśli rzutowanie nie jest możliwe, zwraca null protected void clicked(object sender, EventArgs e) { Button b = sender as Button; if (b != null) b.Text = „Naciśnięto”; }

Kolekcje ArrayList tablica Queue kolejka Stack stos Dictionary struktura słownikowa (łączy klucz-wartość) Hashtable tablica haszująca

Wyjątki (1/3) try { … } catch (IOException exception) catch (Exception exception) finally

Wyjątki (2/3) Dopuszczalne jest użycie samego catch try { … } catch throw: słowo kluczowe umożliwiające zgłoszenie wyjątku

Wyjątki (3/3) Wymagana jest odpowiednia kolejność catch try { … } catch (Exception exception) catch (IOException ioexception) // tutaj nigdy nie dojdziemy, bo IOException jest // specjalizacją Exception, więc poprzedni catch // wyłapie ewentualny wyjątek

Delegaty Odpowiedniki wskaźników do funkcji z C++ public delegate int KtoryMniejszy (object o1, object o2); KtoryMniejszy Porownanie += new KtoryMniejszy (FunkcjaPorownawcza); public int FunkcjaPorownawcza (object o1, object o2) { return (o1>o2); } Tab.sort(Porownanie);

Delegaty i zdarzenia Delegaty są wykorzystywane do obsługi zdarzeń delegate void EventHandler (object sender, EventArgs e); button1.Click += new EventHandler (KliknietoNaPrzycisku); void KliknietoNaPrzycisku (object sender, EventArgs e) { Button nadawca = sender as Button; … }

GENERICS Generics pozwala klasom, strukturom, interfejsom, delegatom i metodom być sparametryzowanym przez typ który przechowują i manipulują nim. Jest podobny do generics w jezyku Eiffel ,Ada lub szablonów w C++.

Dlaczego GENERICS? public class Stack { object[] items; int count; public void Push(object item) {...} public object Pop() {...} } Stack stack = new Stack(); stack.Push(new Customer()); Customer c = (Customer)stack.Pop();

Generics public class Stack<T> { T[] items; int count; public void Push(T item) {...} public T Pop() {...} } Stack<int> stack = new Stack<int>(); stack.Push(3); int x = stack.Pop();

Generics- liczba paramerów public class Dictionary<K,V> { public void Add(K key, V value) {...} public V this[K key] {...} } Dictionary<string,Customer> dict new Dictionary<string,Customer>(); dict.Add("Peter", new Customer()); Customer c = dict["Peter"];

Generics - aliasy using List = LinkedList<int,string>; class ListClient{ static void Main(string[]args) { List list = new List(); list.AddHead(123,"AAA"); }

Generics - kompilacja Kompiluje się do IL (instrukcje i metadane) Proces tworzenia – generic type instantion Po jednej instancji dla każdego typu prostego Jedna instancja dla typów referencyjnych

Generics – nie tylko dane 1/2 Nie tylko przechowywanie danych typu generycznego public class Dictionary<K,V> { public void Add(K key, V value) { ... if (key.CompareTo(x) < 0) {...} // Error, no ... } }

Generics – nie tylko dane 2/2 Rozwiązanie za pomocą rzutowania: public class Dictionary<K,V> { public void Add(K key, V value) { ... if (((IComparable)key).CompareTo(x) <0) {...} ... } }

Generics – Constraints 1/2 Czyli ograniczenia na parametry: public class Dictionary<K,V> where K: IComparable { public void Add(K key, V value) { ... if (key.CompareTo(x) < 0) {...} ... } }

Generics – Constraints 2/2 Ograniczenia mogą dotyczyć wielu Interfejsów, 1 klasy, a także konstruktora new(). public class EntityTable<K,E> where K: IComparable<K>, IPersistable where E: Entity, new() { public void Add(K key, E entity) { ... if (key.CompareTo(x) < 0) {...} ... } }

Metody Generyczne 1/2 Możemy sparametryzować także metody. void PushMultiple<T> (Stack<T> stack, params T[] values) { foreach (T value in values) stack.Push(value); } Stack<int> stack = new Stack<int>(); PushMultiple<int>(stack, 1, 2, 3, 4);

Metody Generyczne 2/2 type inferencing – wywołanie metody z odpowiednim typem generycznym na podstawie parametrów. Stack<int> stack = new Stack<int>(); PushMultiple(stack, 1, 2, 3, 4); tak jak dla klas możemy wprowadzać też ograniczenia dla metod: public class MyClass{ public void SomeMethod<T>(T t) where T :IComparable<T> {...} }

Typ generyczny i rzutowanie 1/3 Niejawnie możemy rzutować do object i do typów występujących w ograniczeniach: class MyClass<T> where T : BaseClass,ISomeInterface { void SomeMethod(T t) { ISomeInterface obj1 = t; BaseClass obj2 = t; object obj3 = t; }

Typ generyczny i rzutowanie 2/3 Jawnie rzutować możemy tylko do interfejsów: class MyClass<T> { void SomeMethod(T t) { ISomeInterface obj1 = (ISomeInterface)t; //Compiles SomeClass obj2 = (SomeClass)t; //Does not compile } }

Typ generyczny i rzutowanie 3/3 Możemy ominąć to ograniczenie używając zmiennej pomocniczej typu object: class MyClass<T> { void SomeMethod(T t) { object temp = t; SomeClass obj = (SomeClass)temp; } Warto używać operatorów is i as.

Dziedziczenie i generics 1/2 Jeżeli klasa dziedziczy z klasy generycznej to musi być podany konkretny typ jako parametr: public class BaseClass<T>{...} public class SubClass : BaseClass<int>{...} Chyba że klasa i podklasa są sparametryzowane tym samym parametrem: public class SubClass<T> : BaseClass<T> {...}

Dziedziczenie i generics 2/2 Przy dziedziczeniu należy powtarzać ograniczenia w podklasach: public class BaseClass<T> where T : ISomeInterface {...} public class SubClass<T> : BaseClass<T> where T : ISomeInterface{...} To samo dotyczy metod wirtualnych: public class BaseClass{ public virtual void SomeMethod<T>(T t) where T : new() {...} } public class SubClass : BaseClass{ public override void SomeMethod<T>(T t) where T : new() {...}

Generics i delegaty Tak jak klasy struktury i interfejsy możemy sparametryzować typem generycznym także delegaty: public delegate void GenericDelegate<T>(T t); public class MyClass{ public void SomeMethod(int number) {...} } MyClass obj = new MyClass(); GenericDelegate<int> del; del = new GenericDelegate<int>(obj.SomeMethod); del(3);

Kolekcje Generyczne System.Collections.Generics i odpowiedniki System.Collections Comparer<T> Comparer Dictionary<K,T> HashTable List<T> ArrayList Queue<T> Queue SortedDictionary<K,T> SortedList Stack<T> Stack IComparable<T> IComparable

Metody anonimowe 1/3 Zdarzenia są obsługiwane przez metody na które wskazują delegaty. class InputForm: Form { ListBox listBox; TextBox textBox; Button addButton; public MyForm() { listBox = new ListBox(...); textBox = new TextBox(...); addButton = new Button(...); addButton.Click += new EventHandler(AddClick); } void AddClick(object sender, EventArgs e) { listBox.Items.Add(textBox.Text); } }

Metody anonimowe 2/3 Ten sam przykład z użyciem metody anonimowej: class InputForm: Form { ListBox listBox; TextBox textBox; Button addButton; public MyForm() { listBox = new ListBox(...); textBox = new TextBox(...); addButton = new Button(...); addButton.Click += delegate { listBox.Items.Add(textBox.Text); }; } }

Metody anonimowe 3/3 Możemy także używać metod anonimowych do wpisywania funkcji “in-line” delegate double Function (double x); class Test { static double[] Apply(double[] a, Function f) { … } static double[] MultiplyAllBy(double[] a, double factor) { return Apply(a, delegate(double x) { return x * factor; }); } static void Main() { double[] a = {0.0, 0.5, 1.0}; double[] squares = Apply(a, delegate(double x) { return x * x; }); double[] doubles = MultiplyAllBy(a, 2.0); } }

Iteratory 1/3 Żeby można było użyć pętli foreach na kolekcji, to kolekcja musi spełniać warunki: Kolekcja musi implementować interfejs IEnumrable. Kolekcja musi mieć bezparametrową metodę GetEnumerator.

Iteratory 2/3 „Numeratory” są trudne do zaimplementowania. Sprawę ułatwiają nam ITERATORY: public class Stack<T>: IEnumerable<T> { T[] items; int count; public void Push(T data) {...} public T Pop() {...} public IEnumerator<T> GetEnumerator() { for (int i = count – 1; i >= 0; --i) { yield return items[i]; } } } Mamy też do dyspozycji instrukcję yield break

Iteratory 3/3 Możemy także zdefiniować kilka iteratorów dla 1 kolekcji: public class Stack<T>: IEnumerable<T> { … public IEnumerator<T> GetEnumerator() { for (int i = count – 1; i >= 0; --i) { yield return items[i]; } } public IEnumerable<T> TopToBottom { get { return this; } } public IEnumerable<T> BottomToTop { get { for (int i = 0; i < count; i++) { yield return items[i]; } } } }

Iteratory 3/3 cd.. Użycie: class Test { static void Main() { Stack<int> stack = new Stack<int>(); for (int i = 0; i < 10; i++) stack.Push(i); foreach (int i in stack.TopToBottom) Console.Write("{0} ", i); foreach (int i in stack.BottomToTop) Console.Write("{0} ", i); } }

Partial types 1/2 Podział zawartości 1 klasy w więcej niż jednym pliku np: plik1.cs public partial class Customer { private int id; private string name; private string address; private List<Order> orders; public Customer() { ... } }

Partial types 2/2 Plik2.cs public partial class Customer { public void SubmitOrder(Order order) { orders.Add(order); } public bool HasOutstandingOrders() { return orders.Count > 0; } }

Nullable type 1/3 Wprowadza dla wszystkich typów prostych wartość null. int? Jest to typ wbudowany + wartość null. HasValue - właściwość, która zwraca nam true or false jeżeli typ jest nullable lub nie.

Nullable type 2/3 Operacje arytmetyczne z null-em dają null Operatory >,<,<=, >= zwracają false jeżeli któryś z argumentów jest null. Nowy operator ??. a??b – rezultatem jest a jeżeli a jest not-null i b w przeciwnym przypadku.

Nullable type 3/3 Przykład: int? x = GetNullableInt(); int? y = GetNullableInt(); int? z = x ?? y; int i = z ?? -1; Operator ten działa też dla typów referencyjnych: string s = GetStringValue(); Console.WriteLine(s ?? "Unspecified");

PODSUMOWANIE Została zachowana maksymalna zgodność wstecz. Jeszcze większy wachlarz konstrukcji. Ciągle najlepszy język do programowania na platformie .NET

Koniec. Dziękuję za uwagę.