Język C 4 0 using System

Język C# ( 4. 0 ) using System; namespace He. Wo { class Hello { static void Main(string [] args) { Console. Write. Line("Hello World!"); } } }

Typy Danych § wartości ( stos , pełne kopiowanie ) logiczne numeryczne egzemplarze struktur § referencje ( sterta , kopiowanie referencji ) obiekty klas tablice ciągi znaków ( string )

Type C# CTS CLS Bytes Default bool Boolean Y 1 false byte Byte Y 1 0 sbyte SByte N 1 0 short Int 16 Y 2 0 int Int 32 Y 4 0 long Int 64 Y 8 0 ushort UInt 16 N 2 0 uint UInt 32 N 4 0 ulong UInt 64 N 8 0 float Single Y 4 0. 0 double Double Y 8 0. 0 char Char Y 2 0

Deklaracje i definicje zmiennych int Alfa , Beta , Gamma = 5 ; Operator przypisania wartości Beta = Gamma; Beta = 12; Beta = Alfa; // OK // błąd kompilacji Stałe const double Kurs = 3. 857 ;

Typy implikowane (3. 0) var a = 5; var b = 'K'; var c = 128 L; var d = 15. 332; var e = "Ala ma kota"; a = 4654434 L; e = 4. 5; // int // char // long // double // string // long -> int // błąd ● tylko zmienne lokalne w funkcjach nie mogą być składowymi klas

Rzutowanie automatyczne - rozszerzające ( bez ostrzeżenia ) - zawężające ( błąd kompilacji ) wymuszone (int) Long. Value; int li 32 = 5; long li 64; li 64 = li 32; // OK. li 32 = li 64; // błąd kompilacji li 64 = 100111222333; li 32 = (int) li 64; // błędna wartość // 1236974525

Typy rozszerzone ( nullable ) (2. 0) double? Cena; // { numbs, INF, Na. N, null } // Cena = 7. 54 ; // Cena = null ; // if ( Cena. Has. Value ) Cena += 1. 4;

Opakowanie - Rozpakowanie long aaa = 1234567890 , bbb ; object obj. Long = aaa ; // stos sterta bbb = (long) obj. Long ; // sterta stos // Invalid. Cast. Exception Typ logiczny bool dobrze; int alfa = 5; dobrze = 0; // błąd dobrze = 3 * alfa + 1; // błąd dobrze = true; // OK dobrze = alfa > 10; // OK

Typy wyliczeniowe enum Wyliczanka { Eme, Due, Fake = 10, Drake } // int // == 0 // == 10 // == 11 enum Maly : byte // byte { mini , mikro } dziedziczenie z System. Enum. Is. Defined(typeof(Maly) , "nano");

Funkcje i właściwości typu zmienne typów będących wartościami są egzemplarzami struktur dziedziczą funkcje z typu System. Object. Value. Type ─ Get. Type( ) // obiekt Type określający typ • dla typów wyliczeniowych (np. Console. Color) : var Lista. Kolorów = // tablica stałych Enum. Get. Values(Console. Color. Black. Get. Type()); ─ To. String( ) // konwersja binarno – znakowa long Lo. Val = 15342443 ; Lo. Val. To. String ( );

właściwości typów liczbowych Max. Value // wartość maksymalna Min. Value // wartość minimalna long x = long. Max. Value; int y = int. Min. Value;

Łańcuchy znaków UNICODE (UTF - 16) string typ referencyjny zawartość łańcucha niezmienna dziedziczy z typu System. String Length, Concat, Compare. To, Copy, Insert , Pad. Left , Pad. Right , Remove , Replace , To. Lower , To. Upper , Format = , + , == , != , [ ] string Nap 1 , Nap 2 = "dobry napis" ; Nap 1 = Nap 2 ; // nowa referencja Nap 1 = Nap 2. To. Upper( ); // nowy łańcuch

znaki sterujące jak w C ( @ wyłącza przetwarzanie ) string Opis 1 = "n. Wynikit: " ; string Opis 2 = @"n. Bez zmiant: " ; Przekształcanie wnętrza łańcucha klasa System. Text. String. Builder using namespace System. Text; String. Builder my. Buffer = new String. Builder ("Ala ma kota"); my. Buffer. Append(„ a Ola psa. "); my. Buffer. Insert(11, ', '); string Ready = my. Buffer. To. String(); // Ala ma kota, a Ola psa.

Wprowadzanie – wyprowadzanie danych klasa System. Console ─ int Read ( ) // 1 znak (NL, -1) ─ string Read. Line ( ) // do NL ─ string Write ( string ) // bez NL ─ string Write. Line ( string ) // z NL // Console. Write. Line( x. To. String() ); Console. Write. Line( x ); // konwersja Console. Write. Line( x. To. String() + ", " + y. To. String() );

Console. Write ("format", w, . . , w) // bez NL Console. Write. Line ("format", w, . . , w) // z NL format "zzz{0}zzz{1}zzz{0}zzz{2}zzz. . . " ─ "zzz" dowolny ciąg znaków (może być pusty) ─ {0} {1} {2}. . . pozycje kolejnych dalszych argumentów ─ w, . . . , w ciąg wyrażeń 0

można stosować znaki formatujące {K: Zs} lub {K, P: Zs} ─ K numer pozycji ─ Z znak formatujący ─ P szerokość pola ─ s liczba cyfr po kropce znak znaczenie C c waluta (wg. Windows) D d całkowite dziesiętne E e notacja wykładnicza F f niecałkowite dziesiętne G g z wykładnikiem lub bez N n format narodowy X x postać heksydecymalna

int ii = 34; double dd = 2. 52345324 ; string str = "n. Opis wyniku : t" ; Console. Write. Line( "{0} {1} albo {1, 12: D} i {2} lubn " + "{2, -15: F 3} lub {2: E 5} lub {3} " , str , ii , dd. To. String() ) ; //Opis wyniku : 34 albo 34 i 2, 52345324 lub // 2, 523 lub 2, 52345 E+000 lub 2, 52345324

konwersja znakowo – binarna (kultura - ustawienia narodowe) - System. Type. Parse(string) string str; double dd = 2. 5; str = Console. Read. Line( ); // 12, 45 dd = double. Parse( str ); // błędny format -> błąd wykonania Console. Write. Line( dd ); // 12, 45

bool dobrze = false; string str; double dd = 2. 5; while ( ! dobrze ) { str = Console. Read. Line( ); dobrze = double. Try. Parse(str, out dd); } Console. Write. Line(dd); // VS. NET 2005

- klasa Convert To. Byte To. SByte To. Char To. Decimal To. Double To. Single To. Int 16 To. Int 32 To. Int 64 To. UInt 16 To. UInt 32 To. UInt 64 To. String st; long war; str = Console. Read. Line(); 124534567043 war = Convert. To. Int 64(str); // // format

kultura (ustawienia narodowe) - związana z każdym procesem obliczeniowym (wątkiem) - klasa Culture. Info using System. Threading; using System. Globalization; // Culture. Info ci = new Culture. Info("de-DE"); Thread. Current. Culture = ci;

przesuwanie kursora // VS. 2005 Console. Cursor. Visible = false; Console. Foreground. Color = Console. Color. Red; Console. Background. Color = Console. Color. White; Console. Cursor. Left = X; // od lewej Console. Cursor. Top = Y; // od góry Console. Write("+"); // o 1 w prawo Console. Cursor. Left = X; // powrót Console. Set. Cursor. Position( X, Y ); Console. Clear();

znaki sterujące Console. Key. Info znak; // znak = Console. Read. Key(); if( Console. Key. Up. Arrow == znak. Key) { . . } // Backspace, Home, End, Enter, Escape // Arrows, Fxx, klawiatura numeryczna // Play, Volume, . . . Console. Beep( 3000, 1000 ); // 3000 Hz, 1000 ms Call, S 0, Kultura, Move

Wyrażenia arytmetyczne i logiczne operatory i zasady tworzenia jak w C++ dodatkowo is as oraz => konwersja wartości - rozszerzająca automatycznie - zawężająca błąd int a = 2 L; // błąd float f = 2. 45; // błąd rzutowanie ( typ ) wyrażenie

lokalne testowanie poprawności checked // typy całkowitoliczbowe int a 1 = 200000; a 1 = a 1 + 200000; // -294967296 a 1 = checked ( a 1 + 200000 ); // wyjątek long l 1 = 500000; a 1 = l 1; kompilacji a 1 = ( int ) l 1; // błąd // -294967296 a 1 = checked ( ( int ) l 1 ); // wyjątek

globalne testowanie poprawności Properites / Build / Advance + Check for arithmetic overflow/underflow lokalne wyłącznie testowania unchecked int a 1 = 200000; a 1 = a 1 + 200000; // wyjątek a 1 = unchecked ( a 1 + 200000 ); -294967296

Instrukcje warunkowe if . . else // jak C++ // warunek wyrażenie logiczne if ((x + 4) > 1 && (y++ < 8)) // || // obliczenie optymalizowane if ((x + 4) > 1 & (y++ < 8)) // | // pełne obliczenie // switch // jak C++ // instrukcja break konieczna

pętle ( ogólnie jak C++ ) for ( int i = 1 ; i < 5 && dalej ; ++i ) {. . . . } // koniec widoczności zmiennej i while , do. . . while // jak C++ foreach // wymagany IEnumerator

Struktury są zawsze wartościami (na stosie, kopiowanie) mogą zawierać interfejsy, funkcje składowe i konstruktory z argumentami są zawsze zapieczętowane modyfikatory dostępu do pól modyfikator opis public dostępne zewsząd (domyślny) private tylko wewnątrz struktury / klasy protected dla klas dziedziczących internal tylko w pakiecie protected internal dla klas dziedziczących w pakiecie

public struct Osoba { public string Imie; public string Nazwisko; public long Pesel; } Osoba Prezes; Prezes. Imie = "Adam" ; Prezes. Nazwisko = "Betoński" ; Prezes. Pesel = 54031203287; Osoba Emeryt ; Emeryt = Prezes ;

pakowanie i rozpakowanie object Agent = Emeryt; // sterta, brak dostępu do pól long kto = Agent. Pesel; // błąd Osoba X_007 = ( Osoba ) Agent ; // stos, jest dostęp do pól kto = X_007. Pesel; // OK

public struct Komputer { public string Marka; public short Cena; public Komputer (string mm, short cc) { Marka = mm; Cena = cc; } } object PC = new Komputer ( "Alfa", 3000 ); short cc = PC. Cena; // błąd Komputer komp = (Komputer) PC; cc = komp. Cena; // OK

Tablice jednowymiarowe int [ ] Tab_A ; // zmienna referencyjna Tab_A = new int [ 120 ] ; // 0. . . 119 // automatyczne zerowanie string [ ] Tab_B = new string [ X + 5 ] ; // automatycznie NULL

string [ ] Tab_D = new string [ 3 ] { "Alfa", "Beta", "Gamma" }; double [ ] Tab_C = { 1. 2 , 4. 5 , 4. 4 } ; // Tab_A [ 0 ] = 55 ; Tab_D [ 2 ] = "Jota" ; // System. Index. Out. Of. Range. Exception var T = new double[ ]{1. 1, 2. 2, 3. 3}; // tylko jako tablica lokalna w funkcji

wielowymiarowe, pełne int [ , ] Mat = new int [ 9 , 7 ] ; Mat [ 3 , 5 ] = 121 ; // int [ , ] T 23 = { {1, 2, 3}, {4, 5, 6} } ; // var T 2 = new long [ , ] { { 10, 20, 30 }, { 100, 200, 300 } }; // tylko jako tablica lokalna w funkcji

● wielowymiarowe, niepełne long [ ] Arr = new long [ 5 ] [ ] ; // zadana liczba wierszy, // zmienna liczba kolumn w wierszu for ( int i = 0 ; i < Arr. Length ; ++i ) Arr [ i ] = new long [ i + 5 ] ; Arr [ 2 ] [ 3 ] = 12212212234543 ;

kopiowanie tablic int[] T = { 1, 3, 5, 7, 9 }; int[] R = new int [10]; R = T; // kopiowanie referencji, R ma 5 elementów T[0] = 99; // zmiana wartości R[0] R = (int[]) T. Clone(); // kopia T T[1] = 88; // R[1] bez zmian int[] S = new int [10]; T. Copy. To( S, 2 ); // kopiowanie elementów T -> S od elementu 2

dziedziczenie z System. Array właściwości Length, Range funkcje Binary. Search , Clear , Clone, Copy. To Get. Length, Get. Lower. Bound , Get. Upper. Bound Get. Value , Set. Value , Reverse , Sort

int x = 0; Array A 3 D = Array. Create. Instance(x. Get. Type(), 12, 15, 24); // Range = 0, 1, 2 : M, W, K for (int i = A 3 D. Get. Lower. Bound(0); i <= A 3 D. Get. Upper. Bound(0); ++i) // M for (int j = A 3 D. Get. Lower. Bound(1); j <= A 3 D. Get. Upper. Bound(1); ++j) // W for (int k = A 3 D. Get. Lower. Bound(2); k <= A 3 D. Get. Upper. Bound(2); ++k) // K A 3 D. Set. Value((i * 100 + j * 10 + k), i, j, k); Console. Write. Line("Multidimensional Array: "); Console. Write. Line("Rankt. Lowert. Upper"); for (int i = 0; i < A 3 D. Rank; ++i) Console. Write. Line("{0}t{1}t{2}", i, A 3 D. Get. Lower. Bound(i), A 3 D. Get. Upper. Bound(i));

Multidimensional Array: Rank Lower Upper 0 0 11 1 0 14 2 0 23 // string [ ] Napisy = new string [ 10 ]; foreach ( string s in Napisy ) { Console. Writeline( s ); } // interfejs IEnumerator jest dostępny S 1, Mat. Mul, Taba, Ewide

Funkcje tylko funkcje składowe klas niepotrzebne deklaracje ( zapowiedzi ) modyfikatory argumentów modyfikator ( brak ) out ref params opis przez wartość ( kopiowanie ) , argument aktualny musi być zainicjowany przez referencję, argument aktualny może być niezainicjowany przez referencję, argument aktualny musi być zainicjowany zmienna liczba parametrów

public long F ( long p 1 , out int p 2 , ref double p 3 ) { . . . =. . . p 1. . . p 3. . . ; . . . p 2 =. . . . ; . . . p 3 =. . p 1. . . p 2. . . ; . . . return. . ; }

long wynik , a 1 = 229977446633 ; int rezultat ; double zmiana = 21. 4 E 5 ; wynik = F (a 1 + 1 L, out rezultat , ref zmiana); /* nawet gdyby zmienna rezultat miała nadaną wartość przed wywołaniem F, to i tak w funkcji F nie wolno odczytywać tej wartości przed wewnętrznym ustaleniem wartości p 2 */ Ewide. F

dowolna liczba parametrów – params public void Do. Li (ref int Suma, params int [ ] Liczby) { foreach (int li in Liczby) Suma += li; } // int Wynik = 174; Do. Li ( ref Wynik, 3, 5, 22, -7, 12); // 209

wzorce funkcji ( generics ) public void Po. Li (params Ty. Da [ ] Liczby) { foreach (Ty. Da li in Liczby) Console. Write. Line(li. To. String()); // Suma + li; niepoprawne // jedynie przypisanie = } // Po. Li (231. 43, 99. 89, - 15. 2321);

public T Mala < T > (T p 1, T p 2) where T : System. IComparable< T > { T pom; if ( p 1. Compare. To( p 2 ) < 0 ) pom = p 1; else pom = p 2; return pom; } // p 1 < p 2 błąd double x; x = Mala (231. 43, 99. 89);

wartości domyślne i argumenty nazwane ( 4. 0 ) public long FU ( long p 1 , bool p 2 = true , double p 3 = 2. 7 ) {. . . } // long lili; lili = FU ( 127 ); // poprawnie lili = FU ( 127, false ); poprawnie // lili = FU ( 127, false, 3. 9 ); poprawnie // lili = FU ( 127, , 3. 9 ); // błąd lili = FU ( 127, p 3 : 3. 9 ) Named. Par // poprawnie

Klasy public class Simple // partial abstract sealed { public int Liczba = 9; public static double Ulamek = 0. 21 ; // 0 string Napis ; // private public int Suma ( int Liczba ) { return this. Liczba + Liczba ; } internal static double Mar( double Cena ) { return Ulamek * Cena ; }

public Simple ( ) // przeciążony k. domyślny { Liczba = 5 ; } // nie można listy powiązań public Simple ( int Start ) { Liczba = Start ; } public Simple ( Simple s ); { Liczba = s. Liczba ; } }

Simple s 0; // tylko zmienna referencyjna s 0 = new Simple( ); // Liczba == 5 // Simple s 1 = new Simple( ) ; // == 5 Simple s 2 = new Simple( 9 ) ; // == 9 s 2. Liczba += s 2. Suma( s 1. Liczba ); // == 23 Simple s 3 = new Simple( s 2 ); // == 23 // int m = Simple. Mar( 100 ) ; // == 21 // funkcje i składowe statyczne // wywołuje się podając nazwę klasy

modyfikatory dostępu (dla klas i dla składowych) modyfikator opis public dostępne zewsząd tylko wewnątrz klasy (domyślny dla składowych) private protected internal dla klas dziedziczących tylko w pakiecie (domyślny dla klas) dla klas dziedziczących w pakiecie

klasy wieloplikowe (2. 0) // plik Prog 1. cs public partial class Employee { public void Do. Work() { } } // plik Prog 2. cs public partial class Employee { public void Go. To. Lunch() { } }

public partial class A { } public class A { } // błąd // ta sama przestrzeń nazw niekonfliktowe modyfikatory typu klasy ( nie trzeba powtarzać ) public private protected internal abstract sealed niekonfliktowa klasa bazowa i lista interfejsów ( nie trzeba powtarzać ) Win. App

klasy statyczne : - nie wolno tworzyć obiektu - wszystkie składowe statyczne public static class Services { public static int Data 1 = 123; public static void Serv 1(int param) {. . } } // int Res 1 = ++ Services. Data 1 ; Services. Serv 1(78);

● inicjowanie obiektów klas (3. 0) public class Alfa { public int al; public long fa; /* public Alfa( int a, long f) { al = a; fa = f; } */ } // Alfa aa = new Alfa { al = 7, fa = 14 L }; // składowe public // Alfa bb = new Alfa { 7, 14 L }; // błąd

public class Alfa { public int al; public long fa; private char kod; // public Alfa( char kk ) { kod = kk + 5; } } // Alfa aa = new Alfa (0 x 41){ al = 7, fa = 14 L }; // składowe: private // protected public Draw. Rect

● funkcje rozszerzające (3. 0) // Fun(ob) -> ob. Fun() public static class String. Ext // static { public static void Older 03 (this System. String pt) { if (pt[0] > pt[3]) Console. Write. Line(pt[0]); else Console. Write. Line(pt[3]); } public static char Letter. Of. Index (this System. String st, int x) { if (x < 0 || st. Length <= x) return '? '; else return st[x]; }

string st = "Autobus. "; Console. Write. Line(st. Older 03()); // przekład: Older 03(st) Console. Write. Line("{0}, {1}", st. Letter. Of. Index(4), st. Letter. Of. Index(12)); // Letter. Of. Index(st, 4) Letter. Of. Index(st, 12) // o // b, ?

using Lib. One; // biblioteka. dll // public static class Lib. One. Ext { public static void Limit 15 (this Lib. One. Class. One c 1) { if (c 1. X > 15) c 1. X = 15; } } // Class. One cc = new Class. One(); cc. X = 27; Console. Write(cc. X. To. String() + ", "); cc. Limit 15(); // Limit 15(cc); Console. Write. Line(cc. X); //27, 15 Exten

Hermetyzacja składowe prywatne i funkcje dostępu ( jak C++ ) właściwości public class Account { private decimal amount ; private string number ; public decimal Total // zapis i odczyt { get { return amount ; } set { if ( Authorization ( ) ) amount = value ; } } // accessors

public string Who // tylko odczyt { get { return number ; } } } // decimal AC ; string NC ; Account Customer = new Account ( ) ; // AC = Customer. Total ; // get_Amount Customer. Total = AC + 100 ; // set_Amount NC = Customer. Who ; // get_Number Edit encapsulation

public class Base 1 { private double price; public double Price { get { return price; } protected set { price = value; } } } // set dostępne w klasie Base 1 i w klasach pochodnych

● właściwości automatyczne (3. 0) Auto-Implemented Properties public class Point { /* private int x; private int y; public int X {get { return x; } set { x = value; } } public int Y {get { return y; } set { y = value; } } */ // public int X { get; set; } public int Y { get; set; } // nazwy zmiennym nadaje kompilator }

public class Point { public int X { get; private set; } public int Y { get; protected set; } } // nazwy zmiennym nadaje kompilator // zmiana X tylko w klasie Point // zmiana Y tylko w klasie Point // i w klasach pochodnych

właściwości statyczne private static string bankname = " PKO " ; public static string Bank. Name ; { get { return bankname ; } set { bankname = value ; } } składowe tylko do odczytu public readonly decimal Currency ; public static readonly string Acc. Type = "A 1"; // nadawanie wartości tylko w deklaracji lub // w konstruktorze klasy

Typy anonimowe (3. 0) public class Point { public int X { get; set; } public int Y { get; set; } } // var TTT = new {T 1 = new Point { X = 4, Y = 4 }, T 2 = new Point { X = 7, Y = 7 }, T 3 = new Point { X = 2, Y = 2 } }; // klasa lokalna opisująca trójkąt // Console. Write. Line(TTT. Get. Type()); //f__Anonymous. Type 0`3[CS 3. Point, CS 3. Point] Console. Write. Line(TTT. To. String()); //{ T 1 = CS 3. Point, T 2 = CS 3. Point, T 3 = CS 3. Point }

Wiązania dynamiczne ( 4. 0 ) public object Nowy. Klient(. . . ) { object kli = null; if (. . . ) kli = new Klient_A(); else kli = new Klient_B(); . . . return kli; } // Klient_A nowy = (Klient_A) Nowy. Klient(. . . ); if( nowy != null ) { nowy. Nazwisko = "Nowak"; }

dynamic nowy = Nowy. Klient(. . . ); nowy. Nazwisko = "Nowak"; // poprawnie nowy. Nieistniejąca. Funkcja ( ); // błąd wykonania (nie kompilacji) również zmienne proste dynamic liczba = 125. 54; double ile = liczba / 3. 22 ; // poprawne liczba = "Napis"; // poprawne char cc = liczba[0]; // 'N'

dynamiczne statyczne Klient_B kli = new Klient_B(); dynamic dyn. Kli = kli; // statyczna do dynamicznej Klient_B natręt = dyn. Kli; // dynamiczna do statycznej Dyna

Przeciążanie operatorów public class Line { public int Low , High ; // public static Line operator + ( Line L 1 , Line L 2 ) { int a , b; a = L 1. Low < L 2. Low ? L 1. Low : L 2. Low; b = L 1. High > L 2. High ? L 1. High : L 2. High; return new Line ( a , b ) ; } // musi być funkcja statyczna

public static int operator * (Line L 1, int x) { return L 1. Low * x; } } // Line L = new Line { Low = – 2 , High = 7 } ; Line K = new Line { Low = 0 , High = 9 } ; Line LK = L + K ; // ( -2 , 9 ) int Z = LK * 5 ; // -10

Relacja całość - część public class Radio { private string Make ; public void On. Off ( bool on ) {. . . } public Radio ( string name ) { Make = name ; } }

public class Car { private string Pet. Name ; private Radio radio ; public Car( string music , string name ) { radio = new Radio ( music ); Pet. Name = name ; } public Make. Noice ( bool on ) { radio. On. Off ( on ); }} Car My. First = new Car ( "Eltra", "Kaszel" ) ; My. First. Make. Noice ( true );

Klasy zagnieżdżone public class Car { private class Radio //(1) { public void On. Off ( bool on ) {if (on) Console. Write. Line("Booom!"); } } private Radio radio = new Radio ( ); //(2) } // obiektów klasy Radio nie można tworzyć // poza klasą Car (private) Car. Radio rd = new Car. Radio(); // błąd

// po zmianie private -> public (1) public class Radio {. . . } // Car. Radio rd = new Car. Radio(); rd. On. Off(true); // Booom! // // po zmianie private -> public (2) public Radio radio = new Radio(); // Car ca = new Car(); ca. radio. On. Off(true); // Booom!

Dziedziczenie public class Parent { public int a ; public string b ; public Parent ( int Va , string Vb ) { a = Va ; b = Vb ; }} public class Child : Parent // pojedyncze { public long z ; public Child ( int Va , string Vb , long Vz ) : base ( Va , Vb ) { z = Vz ; } }

składowe public są dziedziczone jako public składowe protected są dziedziczone jako private składowe private nie są dziedziczone // klasy zapieczętowane public sealed class Childless {. . . } public sealed class Grandson : Child {. . . }

Funkcje wirtualne public class Employee { protected decimal Payment = 1000 ; public virtual void Bonus ( decimal X ) { Payment += X ; } } public class Manager : Employee { public override void Bonus( decimal X ) { Payment += 5 * X ; } }

public class Proxy : Manager { public new void Bonus ( decimal X ) { Payment += 700; } } public class Boss : Manager { public override void Bonus(decimal X ) { Payment += 12 * X ; } }

Employee [ ] Team = { new Employee ( ) , new Manager ( ), new Proxy ( ), new Boss ( ) } ; for ( int i = 0 ; i < Team. Length ; ++i ) Team [ i ]. Bonus ( 100 ); // 1100 , 1500 , 2200 Proxy wice = new Proxy ( ) ; wice. Bounus ( 100 ) ; // 1700

wywołanie funkcji wirtualnej z klasy bazowej public override Draw ( ) {. . . base. Draw ( ) ; . . } Wydaw

klasy abstrakcyjne i abstrakcyjne funkcje wirtualne public abstract class Root { protected int alfa = 17; public abstract void Print( ); } public class Level 1 Node : Root { public override void Print( ) { Console. Write. Line( alfa ); } }

Finalizacja public class Alfa { Alfa ( ) { Console. Write. Line( "Oto jestem. " ) ; } ~Alfa ( ) // wywoływane przez gc { Console. Write. Line( "Dobranoc. " ) ; } }

Zbieranie śmieci generacje obiektów 0 , 1 , 2 funkcje System. GC GC. Collect ( Nr. Generacji ) //( )- wszystkie GC. Get. Generation ( obiekt ) GC. Max. Generation ( ) GC. Supress. Finalize ( obiekt ) GC. Register. For. Finalize ( obiekt ) GC. Get. Total. Memeory ( ) Fina

Pliki dyskowe i serializacja przestrzeń nazw System. IO informacje o plikach i katalogach - abstrakcyjna klasa bazowa File. System. Info Name Attributes Exists Creation. Time. . . - klasy pochodne File. Info Directory. Info

przetwarzanie katalogów klasa Directory. Info dir 1, dir 2 ; dir 1 = new Directory. Info ( @"C: My. App" ) ; dir 2 = new Directory. Info ( ". " ) // bieżący, zawierający *. exe Create ( ) Delete ( ) Get. Files ( ) Get. Directories ( ) Move. To ( ) Dir. Info

przetwarzanie plików klasa File. Info Open( ) Delete( ) Move. To( ) Open. Read( ) Open. Write( ) parametry otwarcia pliku File. Mode. Append Create Open. Or. Create Truncate File. Access. Read. Write File. Share. None Read. Write

wynikiem funkcji Open ( ) jest referencja obiektu klasy File. Stream umożliwiającego zapis/odczyt do/z pliku bez formatowania ( ciąg bajtów ) File. Info ff = new File. Info (@"C: TempData. txt"); File. Stream fs = ff. Open (File. Mode. Open , File. Access. Read); // albo File. Stream fs = new File. Stream ("Plik. bin", File. Mode. Open, File. Access. Read);

właściwości i funkcje klasy File. Stream Can. Reed Can. Write Can. Seek Length Position Read ( ) Read. Byte ( ) Write. Byte ( ) Seek ( ) Flush ( ) Close ( ) // ciągi bajtów byte [ ] Ta. Ba = new byte [ fs. Length ]; // for ( int i = 0 ; i < fs. Length ; ++i ) Ta. Ba [ i ] = (byte) fs. Read. Byte( ); // albo fs. Read ( Ta. Ba, 0, fs. Length );

fs. Seek(0 L, Seek. Origin. Begin); // . Current // . End // albo fs. Position = 0; for ( int i = 0 ; i < Ta. Ba. Length ; ++i ) fs. Write. Byte( Ta. Ba[ i ]); // albo // fs. Write(Ta. Ba, 0, Taba. Length);

wykrywanie końca pliku int Count = 0; while (Count++ < fs. Length) {. . . } // albo if (fs. Position != fs. Length) {. . . } zamykanie pliku fs. Close( ); File. Info

zapis/odczyt z formatowaniem klasy Object Text. Reader Text. Writer Stream. Reader String. Writer String. Reader Binary. Writer

podstawowe funkcje Text. Writer Text. Reader Write ( ) Peek ( ) Write. Line ( ) Read ( ) Flush ( ) Read. Line ( ) Close ( ) Read. To. End ( )

File. Info fi = new File. Info ( @"C: TempTest. txt" ) ; // klasa pochodna Text. Writer Stream. Writer sw = fi. Create. Text ( ) ; // albo Stream. Writer sw = new Stream. Writer("dane. txt"); // // klasa pochodna Text. Reader Stream. Reader sr = fi. Open. Text ( ) ; // albo Stream. Reader sr = new Steam. Reader("dane. txt");

int a = 398 ; double x = 122. 453 E-42 ; sw. Write. Line ( " Some text. " ) ; // 1 arg sw. Write ( a + " ") ; sw. Write ( x. To. String ( ) ) ; sw. Close ( ) ; // string str ; str = sr. Read. Line ( ) ; a = int. Parse ( sr. Read. Line ( ) ) ; x = double. Parse ( sr. Read. Line ( ) ) ; sr. Close ( );

wykrywanie końca pliku sr. Read. Line() == null podobnie Stream. RW String. Reader String. Writer stw = new String. Writer(); stw. Write. Line("Tekst ćwiczebny. "); // 1 arg stw. Write. Line( a ); stw. Close(); String. Reader str = new String. Reader ( stw. To. String() ); string st = str. Read. Line(); a = int. Parse ( str. Read. Line ( ) ) ; str. Close();

klasy Binary. Reader Binary. Writer Binary. Reader Write ( ) Peek. Char ( ) Seek ( ) Read ( ) Flush ( ) Read. XXX ( ) Close ( ) XXX : Boolean, Bytes, Chars, Int 16, Int 32, Int 64, Double, Decimal, . . . Binary. RW

serializacja automatyczne zapisywanie / odczytywanie obiektów klas do / z pliku using System. Runtime. Serialization. Formatters. Binary ; using System. IO ; // [Serializable] public class Radio { public string Make ; [Non. Serialized] private int something ; // nie zapisywane public bool On ; }

Radio radio = new Radio ( ) ; radio. Make = "Aiwa" ; radio. On = true ; // File. Stream data = File. Create ("Radio. dat"); Binary. Formatter bifoter = new Binary. Formatter(); // bifoter. Serialize ( data , radio ) ; data. Close ( ) ; // data = File. Open. Read ( "Radio. dat" ) ; Radio nn = (Radio)bifoter. Deserialize( data ); Seria

Klasy kolekcji System. Collections // usunąć Generics klasy Array. List // lista dowolnych obiektów Queue // kolejka FIFO Stack // stos LIFO Sorted. List // posortowana lista par // Hashtable // tablica par // // kodowanie mieszające

Array. List // tablica dowolnych obiektów Add, Binary. Search, Clear, Clone, Contains, Copy. To, Index. Of, Insert, Remove, Reverse, Sort // funkcje Capacity, Count właściwości Queue // // kolejka FIFO Enqueue, Dequeue, Peek, Clear, Contains // funkcje Count // właściwość Stack // stos LIFO Push, Pop, Peek, Clear, Contains // funkcje

Sorted. List // lista par // posortowana Add, Clear, Contains. Key, Contains. Value, Get. By. Index, Index. Of. Key, Index. Of. Value, Remove, Set. By. Index // funkcje Capacity, Count, Item // właściwości // Key. Value. Pair – klasa pomocnicza Hashtable // tablica par // kodowanie mieszające Add, Clear, Contains. Key, Contains. Value, Remove // funkcje Capacity, Count, Item // właściwości

public class Auto { public string Name; public double Price; public Auto(string nn, double pp) { Name = nn; Price = pp; } }

Array. List al = new Array. List(); al. Add ( new Auto("A", 100) ); al. Add ( new Auto("B", 20) ); Console. Write. Line("{0}, {1}", ((Auto)al[0]. Price, ((Auto)al[1]). Price); // 100, 20

Sorted. List sl = new Sorted. List(); sl. Add ( "zero", new Auto("A", 100) ); sl. Add ( "jeden", new Auto("B", 20) ); // Console. Write. Line("{0}, {1}, {2}, {3}", ((Auto)sl["zero"]). Price, ((Auto)sl["jeden"]). Price; // 100, 20 // ((Auto)sl. Get. By. Index(0)). Price, ((Auto)sl. Get. By. Index(1)). Price); // 20, 100

Wzorce klas kolekcji generics, typy parametryczne, typy uogólnione Dictionary Sorted. Dictionary Linked. List // dwukierunkowa List // jednokierunkowa Sorted. List Queue Stack

Sorted. List sl = new Sorted. List(); sl. Add(12, 5. 5); sl. Add("B", 9); sl. Add("C", "alfa"); // kompilacja ok // błąd wykonania, porównanie kluczy niemożliwe

Sorted. List al = new Sorted. List (); al. Add("X", 5); al. Add("Y", 7); al. Add("Z", 3); al. Add(5, 2); // błąd kompilacji al. Add("K", 3. 2); // błąd kompilacji // Console. Write. Line("{0}, {1}, {2}", al["X"], al["Y"], al["Z"]); // 5, 7, 3

wzorce kolekcji we wzorcach funkcji class Osoba { public string Imie; public string Nazwisko; public Osoba(string s 1, string s 2) { Imie = s 1; Nazwisko = s 2; } public overrite string To. String( ) { return Imie + " " + Nazwisko; } }

public void Dopisz (List li, params T [ ] dane ) { foreach ( T elem in dane ) li. Add( elem ); } // List lios = new List (); Dopisz(lios, new Osoba("Adam", "Kot"), new Osoba("Anna", "Kotka")); foreach (Osoba os in lios) Console. Write. Line( os );

Interfejsy określają operacje realizowane przez klasę lub jej cechy charakterystyczne klasy abstrakcyjne zawierające deklaracje funkcji abstrakcyjnych public interface INodes_F { int Get. Number. Of. Nodes ( ); } // funkcja abstrakcyjna // lub public interface INodes_P { int Nodes {get; set; } } // właściwość abstrakcyjna

public abstract class Shape { public int Nodes ; public double Surface; } // public class Hexagon : Shape , INodes_F { public int Get. Number. Of. Nodes ( ) { return 6 ; } }

public class Triangle : Shape , INodes_F { public int Get. Number. Of. Nodes ( ) { return 3 ; } } // public class Circle : Shape { . . . }

Hexagon hex = new Hexagon ( ); if ( hex is INodes_F ). . . ; // test // INodes_F inodes 1 = (INodes_F) hex ; // Invalid. Cast. Exception INodes_F inodes 2 = hex as INodes_F ; // NULL int Nodes. Of. Hex = inodes 1. Get. Number. Of. Nodes ( ) ; zmienne reprezentujące interfejsy ( referencje ) mogą być parametrami funkcji interfejs jako typ może być wynikiem funkcji Dzie&Int

hierarchie interfejsów interface IDraw. BW { void Draw. BW ( ) ; } interface IDraw. GS : IDraw. BW { void Draw. GS ( ) ; } interface IDraw. CR : IDraw. GS { void Draw. CR ( ) ; }

public class Picture : IDraw. CR { // implementacja funkcji // Draw. CR , Draw. GS , Draw. BW } // Picture pp = new Picture ( ) ; // IDraw. CR i. CR = pp as IDraw. Cr ; i. CR. Draw. BW ( ) ; i. CR. Draw. GS ( ) ; i. CR. Draw. CR ( ) ;

Interfejsy standardowe System. Collections interfejsy ICollection IDictionary. Enumerator IHash. Code. Provider IList // IEnumerable IEnumerator IClonable IComparable IComparer

przeglądanie kolekcji Library Eh. RL = new Library ( 100000 ) ; foreach ( Book bb in Eh. RL ) {. . . } ; // wymaga w IEnumerable oraz IEnumerator // w klasie Library public class Library : IEnumerable, IEnumerator { private Book [ ] Book. Arr ;

// implementacja IEnumerable public IEnumerator Get. Enumerator ( ) { return ( IEnumerator ) this ; } // implementacja IEnumerator public void Reset ( ) {. . } public bool Move. Next ( ) {. . . } public object Current { get {. . } } }

- iteratory (2. 0) public class Days. Of. The. Week : IEnumerable { string[] m_Days = { "Sun", "Mon", "Tue", "Wed", "Thr", "Fri", "Sat" }; public IEnumerator Get. Enumerator() { for (int i = 0; i < m_Days. Length; i++) yield return m_Days[i]; } } // Days. Of. The. Week week = new Days. Of. The. Week(); foreach (string day in week) System. Console. Write(day + " ");

pełne kopiowanie public class Point { public int x , y ; public Point (int A , int B ) { x = A ; y = B ; } } Point AA , BB ; AA = new Point ( 5, 7) ; BB = AA ; // AA i BB wskazują ten sam // obiekt na stercie (shallow)

// pełne kopiowanie wymaga ICloneable public class Point : ICloneable { public int x , y ; public Point (int A , int B ) { x = A ; y = B ; } public object Clone ( ) { return new Point( this. x , this. y ); } } BB = (Point)AA. Clone(); // nowa kopia

sortowanie public class Point : IComparable { public int X, Y; public int Compare. To ( object ob ) // { < == > } -> { - 0 + } { Point temp = (Point) ob; if ( this. X > temp. X ) return 1; if ( this. X == temp. X ) return 0 ; return -1; }} Point [ ] a. P = new Point [ 100 ]; Array. Sort(a. P); // a. P[3]. Compare. To((object)a. P[7]) Sort. P, Komis

interfejsy parametryczne, generics ICollection < T > IComparer < T > IDictionary < TKey, TValue > IEnumerable < T > IEnumerator < T > IEquality. Comparer < T > IList < T >

klasy, kolekcje i interfejsy parametryczne public class Dict where Key. Type: IComparable { Dictionary dd = new Dictionary(); public Key. Type patt; public void Add(Key. Type key, Ele. Type val) { if (key. Compare. To(patt) != 0 && !dd. Contains. Key(key)) dd. Add(key, val); } }

Dict dis = new Dict(); dis. patt = 25; dis. Add(24, "alfa"); dis. Add(25, "beta"); dis. Add(26, "delta"); dis. Add(26, "gamma"); // {24, alfa}, {26, delta}

Delegacje klasy, których obiekty udostępniają funkcje klasy pochodne System. Multicast. Delegate Składowe klasy System. Multicast. Delegate składowa opis Method nazwa funkcji zawartej w delegacji Target nazwa klasy, w której zdefiniowana jest funkcja lub null dla statycznych Combine( ), +, += dodanie funkcji Get. Invocation. List ( ) lista funkcji zawartych w delegacji Remove( ), -, -= usunięcie funkcji

delegate double Fun(double x, out bool ok); // nowy typ // funkcje nazwane double Sqrt(double x, out bool ok) { if ( x >= 0 ) { ok = true; return Math. Sqrt( x ); } else { ok = false; return 0; } } // double Log (double x, out bool ok) {. . . . }

double z, x = 4. 3; bool dobrze = true; Fun funkcja = new Fun ( Sqrt ); // obiekt delegacji // albo Fun funkcja = Sqrt; // wywołanie z = funkcja ( x, out dobrze ); // sqrt // funkcja = Log; z = funkcja ( x, out dobrze ); log //

tablice delegacji Fun [] Tab. Fun = new Fun[2]; Tab. Fun[0] = new Fun(Sqrt); Tab. Fun[1] = Log; // po ustaleniu indeksu z = Tab. Fun[indeks](x, out dobrze); // double [] Args = {2. 34, 5. 32}; double [] Results = { Tab. Fun[0](Args[0], out dobrze); Tab. Fun[1](Args[1], out dobrze); };

delegacje wielokrotne (multicast) void As. Is(string s) { Console. Write. Line(s); } // void Vers(string s) { Console. Write. Line(s. To. Upper( )); } //

delegate void Print 2(string s); // Print 2 Both = As. Is; Both += Vers; Both("Ala ma kota. "); // Ala ma kota. // ALA MA KOTA. // Both -= As. Is; Both("Ola ma psa. "); // OLA MA PSA if (Both != null). . . Dele, Mul. Dele, Ewide. D

delegacje anonimowe (2. 0) button 1. Click += // delegacja Click delegate(System. Object o, System. Event. Args e) { Message. Box. Show("Click!"); }; // delegate int Del( int x ); // static int n = 79; // składowa klasy int m = 2; // zmienna lokalna Del d = delegate( int k ) { return n + m + k + 3; }; // int F = d(5); // 89 Anonymous

kowariancja i kontrawariancja delegacji (2. 0) ( covariance and contravariance ) class Mammal {. . . } // bazowa class Dog : Mammal {. . . } // pochodna // public delegate Mammal Handler( ); // delegacja public Mammal First. Handler( ) { return new Mammal( ); } public Dog Second. Handler( ) { return new Dog( ); } Handler handler 1 = First. Handler; Handler handler 2 = Second. Handler; // kowariancja

public delegate void Vet ( Dog ); // delegacja public void First. Handler(Dog ds) {. . . } public void Second. Handler ( Mammal ms ) {. . . } // Vet handler 1 = First. Handler; Vet handler 2 = Second. Handler; // kontrawariancja

● wzorce delegacji (generics) (3. 0) delegate R Fun (A arg); // Fun d 1; // long FK (int x) { return (long)x + 1000000 L; } d 1 = FK; // Fun d 2; Fun d 3;

● wyrażenia lambda (funkcje nienazwane) (3. 0) - jeden argument delegate R Fun (A arg); // Fun L 1 = x => x * x + 1; // λ x. x * x + 1 Console. Write. Line( L 1(12) ); // 145 // Fun L 2 = x => (double)x / 2 + 0. 5; // Console. Write. Line( L 2(7) ) ; // 4, 0

- wiele argumentów delegate R Arg 2 (A x, B y); // Arg 2 suma = (x, y) => (long)(x + y + 1); Console. Write. Line(" Suma : " + suma(15, 'A'). To. String()); // Suma : 81 Lambda

Use a delegate when: - An eventing design pattern is used. - The caller has no need access other properties, methods, or interfaces on the object implementing the method. - Easy composition is desired. - A class may need more than one implementation of the method.

Use an interface when: - There a group of related methods that may be called. - A class only needs one implementation of the method. - The class using the interface will want to cast that interface to other interface or class types. - The method being implemented is linked to the type or identity of the class: for example, comparison methods.

Zdarzenia zgłoszenie zdarzenia powoduje wywoływanie wszystkich funkcji zawartych w delegacji powiązanej z tym zdarzeniem public class Car { private float Gas ; public delegate void Gas. Shortage ( string msg ) ; public event Gas. Shortage Yellow ; public event Gas. Shortage Red ;

public void Speed. Up ( double speed ) { if ( Gas < 2 && Yellow != null ) Yellow ( "Only " + Gas. To. String ( ) + " gallons of gas !" ); if ( Gas < 0. 5 && Red != null ) Red ( "Almost no gas !" ) ; } }

public class Driver { private Car My. Car = new Car( ); public void Driving ( ) { My. Car. Yellow += new Car. Gas. Shortage ( Yellow. Light ); My. Car. Red += new Car. Gas. Shortage ( Red. Light ) ; } public void Parking ( ) { My. Car. Yellow -= new Car. Gas. Shortage ( Yellow. Light ) ; }

public static void Yellow. Light (string msg ) { Console. Write. Line ( msg ); } public static void Red. Light (string msg ) { Alarm ( ) ; Console. Write. Line ( msg ); } } Event

Obsługa wyjątków throw nazwa_wyjątku // obiekt klasy dziedziczącej z System. Exception try { . . . } catch ( typ_wyjątku ) { . . . }. . . catch // wszystkie wyjątki { . . . } finally { . . . } Exep

Zapytania ( 3. 0 ) • wyrażenia zapytaniowe - querry expressions • przestrzeń nazw LINQ - Language-Integrated Query • 3 etapy : 1. określenie źródła danych, 2. utworzenie zapytania, 3. wykonanie zapytania.

class First. LINQ { static void Main() { int[] numbers = // 1. Data source. new int[7] { 0, 1, 2, 3, 4, 5, 6 }; // 2. Query creation. var num. Query = from num in numbers where (num % 2) == 0 select num; // 3. Query execution. foreach (int elem in num. Query) { Console. Write("{0} ", elem); }}}

• technologie LINQ • Linq to Objects • Linq to Data. Set • Linq to SQL • Linq to XML IEnumerable< > • Linq to own sources IQueryable< > , IQuery. Provider • J. Matulewski, C# 3, 0 i. Net. 3. 5 Technologia LINQ, Helion, 2008 • Przykłady : http: //msdn. microsoft. com/en-us/vcsharp/aa 336746. aspx

• słowa kluczowe from where select join // źródło danych // filtrowanie danych // pobieranie danych // łączenie danych orderby // sortowanie danych ascending // rosnąco descending // malejąco let // nadanie wartości group // grupowanie danych into // kontynuacja zapytania on // połącz tabele

• funkcje rozszerzające IEnumerable, IEnumerable< > Select, Select. Many // pobieranie danych Order. By, Then. By, Order. By. Descending, Then. By. Descending, Reverse // sortowanie Where // filtrowanie Aggregate, Average, Count, Long. Count, Max, Min, Sum // artymetyczne Cast, Of. Type, To. Array, To. Dictionary, To. List, To. Lookup, To. Sequence // konwersja Element, Default. If. Empty, Element. At, Element. At. Or. Default, First. Or. Default, Last, Last. Or. Default, Single, Single. Or. Default // pobieranie elementu

Equal. All // porównywanie Empty, Range, Repeat Gruop. By // tworzenie // grupowanie Group. Join, Join Skip, Skip. While, // łączenie // pomijanie Take, Take. While All, Any, Contains // wybór // kwantyfikatory Concat, Distinct, Exept, Intersection, Union // operacje na zbiorach

• Linq to Objects -> Linq 1 • Linq to own sources -> Linq 2

Współbieżność przestrzeń nazw System. Threading klasa Thread tworzenie ścieżek i zarządzanie ich wykonywaniem główne funkcje Start Suspend Resume Abort Sleep Get. Hash. Code główne właściwości Current. Thread Name Thread. State Priority Is. Back. Ground Is. Alive

priorytety ścieżek Lowest Below. Normal Above. Normal Highest ścieżki pierwszoplanowe i drugoplanowe ( Fore. Ground / Back. Groung Threads ) – dopóki istnieje przynajmniej jedna ścieżka pierwszoplanowa aplikacja nie jest zamykana przez CLR – po zakończeniu ostatniej ścieżki pierwszoplanowej CLR kończy wszystkie aktywne jeszcze ścieżki drugoplanowe

public class Worker { public bool End. Of. Work = false ; public void Do. Work ( ) // funkcja ścieżki { Console. Write. Line ("Worker's ID is {0}n" + "Worker's name is {1}", Thread. Current. Thread. Get. Hash. Code ( ) , Thread. Current. Thread. Name ) ; for ( int i = 0; i < 1000 && !End. Of. Work ; ++i ) { Console. Write. Line ( i ) ; Thread. Sleep ( 500 ) ; } } // End of Worker

static void Main ( string [ ] args ) { Worker ww = new Worker ( ) ; Thread job = new Thread( new Thread. Start( ww. Do. Work )); // delegacja Thread. Start // funkcja bezargumentowa job. Name = "Ben" ; job. Start ( ) ; Thread. Sleep ( 5000 ); job. Suspend ( ) ; ww. End. Of. Work = true ; job. Resume ( ) ; }

// funkcje z argumentami class Add. Params // klasa argumentu { public int a, b; public Add. Params(int numb 1, int numb 2) { a = numb 1; b = numb 2; } }

class Program { void Add(object data) // funkcja ścieżki { if (data is Add. Params) { Add. Params ap = (Add. Params)data; Console. Write. Line("{0} + {1} is {2}", ap. a, ap. b, ap. a + ap. b); } }

void Run ( ) { Add. Params ap = new Add. Params(10, 10); Thread t = new Thread( new Parameterized. Thread. Start(Add)); t. Start(ap); // przyśnij, aby druga ścieżka // zakończyła pracę Thread. Sleep(50); } } Param. Thread

asynchroniczne wykonywanie delegacji public delegate int Binary. Op(int x, int y); int Add(int x, int y) { Thread. Sleep(5000); return x + y; } // Binary. Op b = new Binary. Op(Add); // wywołanie synchroniczne, ta sama ścieżka int answer = b(10, 10); // lub int answer = b. Invoke(10, 10);

// asynchronicznie, odrębna ścieżka Binary. Op b = new Binary. Op(Add); // Start secondary thread IAsync. Result ift. AR = b. Begin. Invoke(10, null, null); // Do other work on primary thread. . . int answer = b. End. Invoke(ift. AR); Console. Write. Line("10 + 10 is {0}. ", answer); Async. Del

// funkcje zwrotne bool Ready = false; void Add. Complete(IAsync. Result itf. AR) { Console. Write. Line("Your addition is ready"); Ready = true; } // IAsync. Result ift. AR = b. Begin. Invoke(10, new Async. Callback(Add. Complete), null); while (!Ready) { // other work is performed here. . . } int answer = b. End. Invoke(ift. AR); Async. Call

wykonywanie cykliczne void Print. Time(object state) { Console. Write. Line("Time is: {0}", Date. Time. Now. To. Long. Time. String()); } Timer. Callback time. CB = new Timer. Callback(Print. Time); Timer t = new Timer(time. CB, null, 0, 1000); // delegacja, parametr, // opóźnienie startu, interwał // ścieżka drugoplanowa Timer

synchronizacja dostępu do obiektów współużytkowanych ─ lock ( słowo kluczowe ) ─ System. Treading. Semaphore ─ System. Treading. Mutex ─ System. Treading. Monitor ─ System. Treading. Interlocked ─ synchronizacja za pomocą zdarzeń ─ atrybut wykluczania

public class Shared. Data_1 { private Records [ ] Data. Base ; object Update. Lock; public Update ( string str ) { lock ( Update. Lock ) { . . . // aktualizacja } } } Adders

public Semaphore sem 1 = new Semaphore ( init_val, max_val ); // count = init_val public class Shared. Data_2 { private Records [ ] Data. Base ; public Update ( string str ) { sem 1. Wait. One( ); // if ( count != 0 ) wait; --count; else . . . // aktualizacja sem 1. Release( ); // ++count; }

public Mutex mut 1 = new Mutex ( ); public class Shared. Data_2 { private Records [ ] Data. Base ; public Update ( string str ) { mut 1. Wait. One( ); // request ownership // of a mutex . . . // updating mut 1. Release. Mutex( ); // release ownership } } // ścieżki są identyfikowane

public class Shared. Data_3 { private Records [ ] Data. Base ; object Update. Object; public Update ( string str ) { try { Monitor. Enter ( Update. Object ). . . // aktualizacja } finally // zawsze się wykona { Monitor. Exit ( Update. Object ) ; } } } //. Try. Enter . Wait() . Pulse()

public class Main. Counter // Interlocked { private long Counter = 0; public void Inc ( ) // + 1 { Interlocked. Increment( ref Counter ); } public void Dec ( ) // - 1 { Interlocked. Decrement( ref Counter ); }

public void Exch ( ref Value ) // { Interlocked. Exchange( ref Counter, ref Value ); } public void Comp. Exch ( val 1, val 2 ) { Interlocked. Compare. Exchange ( ref Counter, val 1, val 2 ); } // if (Counter == val 1) // Counter = val 2; }

synchronizacja ścieżek za pomocą zdarzeń ─ Manual. Reset. Event (true / false) ─ Auto. Reset. Event (true / false) ─ Reset() false ─ Set() ─ Wait. One() true : Manual bz Auto false, gdy było true Reset. Event

atrybut wykluczania Synchronization using System. Runtime. Remoting. Contexts; // Thread safe [Synchronization] class Services : Context. Bound. Object { public void Read (. . . ) {. . . } public void Print (. . . ) {. . . } public void Update (. . . ) {. . . } } // wszystkie funkcje wykonywane niepodzielnie

pula ścieżek CLR ─ powołanie nowej ścieżki ( async delegate ) powoduje uruchomienie jednej z oczekujących ścieżek utworzonych dla programu przez CLR ─ można do kolejnych ścieżek puli przypisywać funkcje do wykonania ( poprzez delegację Wait. Callback ) - ścieżki drugoplanowe [Synchronization] public class Printer : Context. Bound. Object { public void Print. Numbers() { . . . } }

Printer prin = new Printer(); Wait. Callback work. Item = new Wait. Callback(Print. The. Numbers); // Queue the method ten times. for (int i = 0; i < 10; i++) Thread. Pool. Queue. User. Work. Item(work. Item, prin); // void Print. The. Numbers(object state) { Printer task = (Printer)state; task. Print. Numbers(); }

współbieżne wykonywanie zadań TPL – Task Parallel Library using System. Threading. Tasks; ─ współbieżne przetwarzanie rozłącznych zbiorów danych Parallel. For ( from, to, action ) Parallel. For. Each ( data_source, action ) // również z dodatkowymi parametrami Parallel. For ( 0, 4, Do. Work ); // powołanie 5 ścieżek, z których każda // wykonuje funkcję zawartą w delegacji Do. Work Data. Para

─ współbieżne obliczenia Parallel. Invoke( action [ ] ac_list) // powołanie dla każdej akcji z ac_list // ścieżki wykonującej tę akcję ─ przerwanie wykonania wszystkich ścieżek Cancelation. Token Task. Para

współbieżne zapytania PLINQ As. Parallel() With. Cancellation() With. Degree. Of. Parallelism() // private Cancellation. Token. Source cancel. Token = new Cancellation. Token. Source() // cancel. Token. Cancel();

int[] mod. Three. Is. Zero = null; // source – vector of integers try { mod. Three. Is. Zero = (from num in source. As. Parallel(). With. Cancellation(cancel. Token) where num % 3 == 0 orderby num descending select num). To. Array(); } catch (Operation. Canceled. Exception ex) { Console. Write. Line( ex. Message ); }

Przestrzeń nazw łączy zdefiniowane typy ( klasy, struktury, delegacje, zdarzenia, wyliczenia) using System ; namespace My. Space { public class Alfa {. . . } public class Beta {. . . } gdy definicje klas w kilku plikach należy powtórzyć deklarację namespace

korzystanie z przestrzeni nazw w innej przestrzeni using System ; using My. Space ; namespace Next. Space { public class Alfa_1 : Alfa {. . . } public class Alfa_2 : My. Space. Alfa // gdy konfliktowe nazwy {. . } }

przestrzeń nazw definiująca stałe namespace Constants { public sealed class CT { public static readonly double pi = 3. 1415926536 ; public static readonly double e = 2. 718285 ; private CT( ) {} } } using Constants ; double radius = 23. 4 ; double perimeter = 2. 0 * CT. pi * r ;

Pakiety i odzwierciedlenie ( refleksja ) typów pakiet ( assembly ) ─ aplikacja ─ biblioteka Manifest Metadane Typów CIL Zasoby . . . .

składniki przestrzeni nazw System. Reflection Klasa Opis Assembly wczytanie pakietu, analiza manifestu lista typów ( klas , struktur ) Assembly. Name Method. Info Parameter. Info Property. Info Field. Info wersja, ustawienia regionalne opis funkcji składowej opis parametru opis właściwości opis danej składowej

tworzenie biblioteki. dll typ projektu: Class Library np. Car. Tune. Up. Lib. dll public Garage Wash. Car() , Change. Oil(). . . korzystanie z biblioteki za pomocą Add Reference dodać bibliotekę Car. Tune. Up. Lib // using Car. Tune. Up. Lib ; public static int Main ( string [ ] args ) { Garage Blue. Nut = new Garage ( ) ; Blue. Nut. Change. Oil (. . . ) ; . . . }

dynamiczne ładowanie biblioteki using System ; using System. Reflection ; using System. IO ; Assembly a = Assembly. Load ( "Car. Tune. Up. Lib" ); // Car. Tune. Up. Lib. dll tam gdzie. exe // klasy Type [ ] Classes = a. Get. Types( ); // odczytywanie składowych Type ctulg = a. Get. Type("Car. Tune. Up. Lib. Garage"); Member. Info [ ] mi = ctulg. Get. Members( ); // podobnie parametry funkcji

dynamiczne wywoływanie funkcji // tworzenie klasy object obj = Activator. Create. Instance( ctulg ); // Method. Info wash = ctulg. Get. Method( "Wash. Car" ); wash. Invoke( obj, null ); bezargumentowa // object [ ] Tab. Par = { par 1, par 2, . . . }; xxx. Invoke ( obj, Tab. Par ); // z argumentami

pakiety prywatne i współużytkowane ( Global Assembly Cache ) wersje pakietów współużytkowanych a. b. c. d ─ a : główny numer wersji ─ b : podrzędny numer wersji ─ c : numer kolejny kompilacji ─ d : liczba szybkich poprawek gdy różne a lub b wersja nieodpowiednia