Nowa wersja C#

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

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

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

4. Wprowadzenie • 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

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

6. 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

7. Klasy z atrybutem sealed • Jeżeli deklaracja klasy zawiera atrybut sealed, to nie jest możliwe jej dziedziczenie sealedpublicclass MojaKlasa { }

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

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

10. 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

11. 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();

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

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

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

15. Typy proste 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 i typy referencyjne

16. 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

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

18. 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;

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

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

21. 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

22. 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)

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

24. 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”: ZrobCos(); break; case „Nowak”: ZrobCosInnego(); break; }

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

26. 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++) { … }

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

28. Tablice a „params” • Pozwala tworzyć metody z nieokreśloną liczbą argumentów publicint 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

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

30. Implementacja interfejsów interface ITestable { bool TestMe(); } publicclass MojaKlasa : ITestable { bool TestMe() { … } }

31. 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)

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

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

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

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

36. 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 }

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

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

39. 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++.

40. 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();

41. 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();

42. 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 newDictionary<string,Customer>(); dict.Add("Peter", new Customer()); Customer c = dict["Peter"];

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

44. 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

45. 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 ...}}

46. 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) {...} ... }}

47. 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) {...} ... }}

48. 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) {...} ... }}

49. 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);

50. 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> {...} }