Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

C#, Visual Studio 2010,.NET 4.0 dr inż. Marcin Radom Instytut Informatyki, Politechnika Poznańska laboratorium Programowania Wizualnego 1.

Podobne prezentacje


Prezentacja na temat: "C#, Visual Studio 2010,.NET 4.0 dr inż. Marcin Radom Instytut Informatyki, Politechnika Poznańska laboratorium Programowania Wizualnego 1."— Zapis prezentacji:

1 C#, Visual Studio 2010,.NET 4.0 dr inż. Marcin Radom Instytut Informatyki, Politechnika Poznańska laboratorium Programowania Wizualnego 1

2 Część I: Wstęp, C# i.NET 2

3 CLR – Common Language Runtime CTS – Common Type System CLS – Common Language Specification JIT(ter) – Just-in-time Compiler CIL – Common Intermediate Language (przez JIT).NET Metadata.NET Asembly Manifest 3 Tajemnicze skróty z.NET

4 ildasm.exe ( \Program Files\Microsoft SDKs\7.0A\bin\ ) Reflector ( gate.com/products/reflector )http://www.red- gate.com/products/reflector 4 Użyteczne programy

5 5 Część II: Programowanie w C#

6 csc.exe ( dostęp np. poprzez link w zainstalowanym folderze menu Start ) Parametry: /out /target:exe (library, module, winexe) C:\csc.exe /target:exe Program.cs C:\csc *.cs C:\csc 6 Kompilator konsolowy

7 Pliki *.rsc # External assembly references. /r:System.Windows.Forms.dll # Output and files to compile (using wildcard syntax). /target:exe /out:Program.exe *.cs csc.rsp ( \Windows\Microsoft.NET\Framework\ ) 7

8 Inne programy Notepad++ SharpDevelop Mono Visual C#2010 Express 8

9 Cechy MS Visual Studio 2010 Solution Explorer Utility Referencing External Assemblies Project Properties Class View Utility Object Browser Utility Integrated Support for Code Refactoring Code Expansion and Surround With Technology Visual Class Designer 9

10 Część III: Podstawy (1) 10

11 Hello World w C# using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplicationExemplar { class Program { static void Main(string[] args) { Console.WriteLine("Hello World!"); Console.WriteLine(); Console.ReadLine(); } 11

12 Przetwarzanie parametrów wejściowych for(int i = 0; i < args.Length; i++) Console.WriteLine("Arg: {0}", args[i]); -wyświetli listę parametrów startowych foreach(string arg in args) Console.WriteLine("Arg: {0}", arg); -jak wyżej string[] theArgs = Environment.GetCommandLineArgs(); foreach(string arg in theArgs) Console.WriteLine("Arg: {0}", arg); -jak wyżej 12

13 Obiekty Environment, Console – i ich przydatne metody (do sprawdzenia we własnym zakresie) Environment.OSVersion (ProcessorCount, Version) Console.WriteLine (ReadLine, Beep(), BackgroundColor, BufferHeight, Width, Title, Clear, etc. ) Console.WriteLine( {0} oraz {0}, 9 ); {0:c} {0:d9} {0:f3} etc… 13

14 Zmienne float L1 = 7.4F; (bez F – double) long L2 = 10D; (bez D – int) ponieważ liczby w C# to struktury, można wykonać operacje: 12.GetHashCode(); //12 12.Equals(23); //FALSE 12.ToString(); //12 double.MaxValue double.PositiveInfinity, etc… 14

15 BigInteger – na naprawdę duże liczby System.Numerics (References->Add reference ->zakładka.NET ) static void UseBigInteger() { Console.WriteLine("Use BigInteger:"); BigInteger dlug = BigInteger.Parse( "); Console.WriteLine("{0}", dlug); Console.WriteLine("{0}", dlug.IsEven); Console.WriteLine("{0}", dlug.IsPowerOfTwo); BigInteger dlugUSA = BigInteger.Multiply(dlug, BigInteger.Parse(" "); Console.WriteLine("{0}", dlugUSA); } 15

16 Łańcuchy String – czyli to co wszyscy znają Łańcuchy dosłowne - wszystko wewnątrz jest traktowane jako łańcuch, nawet (a raczej: zwłaszcza) wszystkie znaki specjalne jak / \ itd. StringBuilder (System.Text) - jeżeli chcemy oszczędzać pamięć 16

17 Rozszerzanie / zawężanie typów danych implicit / explicit – sposób przypisywania zmiennych różnych typów – pierwszy to domyślny, nie działa przy przekraczaniu zakresu typu, drugi wprost mówi kompilatorowi, że wiemy co robimy, np. zmienna_int = (int)wielki_float; checked / unchecked Opcje domyślne dla środowiska w kwestiach powyższych: Properties -> Build -> [Advanced]Button 17

18 Zmienna typu zmienna, czyli typ var var cos = 0; cos.GetType().Name //wynik: int var myInt = 0; var myBool = true; var myString = "Time, marches on..."; Błędy: public var cos = 0; public var Metoda(var x); var cos; cos=0; var obiekt = null; var? nic = nowyObiekt(); var? blad = 12; 18

19 (Elementarne) konstrukcje języka Pętle: foreach ; for while ; do / while Instrukcje warunkowe: if / else switch () { case 1: …. break; case 2: …. break default: …. break } 19

20 Część IV: Podstaw ciąg dalszy 20

21 Parametry argumentów metod: out, ref, params OUT – wywoływana metoda MUSI zwrócić wartość REF – wywoływana metoda może trwale zmienić wartość PARAMS – w skrócie(wielkim): nieokreślona liczba zmiennych pewnego typu public static void SwapStrings(ref string s1, ref string s2) { string tempStr = s1; s1 = s2; s2 = tempStr; } static void Main(string[] args) { Console.WriteLine("**********"); string s1 = "Flip"; string s2 = "Flop"; Console.WriteLine("Before: {0}, {1} ", s1, s2); SwapStrings(ref s1, ref s2); Console.WriteLine("After: {0}, {1} ", s1, s2); Console.ReadLine(); } Before: Flip, Flop After: Flop, Flip 21

22 static double Srednia(params double[] values) { Console.WriteLine(Ile: {0}", values.Length); double sum = 0; if (values.Length == 0) return sum; for (int i = 0; i < values.Length; i++) sum += values[i]; return (sum / values.Length); } double average; average = Srednia(4.0, 3.2, 5.7, 64.22, 87.2); Console.WriteLine("Average of data is: {0}", average); double[] data = { 4.0, 3.2, 5.7 }; average = Srednia(data); Console.WriteLine("Average of data is: {0}", average); 22 params

23 Parametry opcjonalne (.NET 4.0) static void EnterLogData(string message, string owner = "Programmer") { Console.Beep(); Console.WriteLine("Error: {0}", message); Console.WriteLine("Owner of Error: {0}", owner); } static void Main(string[] args) { EnterLogData(ERROR"); EnterLogData(ERROR", Ja"); Console.ReadLine(); } 23

24 Wywoływanie metod z nazwanymi parametrami (.NET 4.0) - Kolejność wywołania: dowolna static void Main(string[] args) { Metoda(message: "Test", textColor: ConsoleColor.DarkRed, BackgroundColor: ConsoleColor.White); Metoda(backgroundColor: ConsoleColor.Green, Message:"Testing...",textColor:ConsoleColor.DarkBlue); Console.ReadLine(); } static void Metoda(ConsoleColor textColor, ConsoleColor backgroundColor, string message) {... } 24

25 Przeciążenie metod static int Add(int x, int y) { return x + y; } static double Add(double x, double y) { return x + y; } static long Add(long x, long y) { return x + y; } static void Main(string[] args) { Console.WriteLine(""); Console.WriteLine(Add(10, 10)); Console.WriteLine(Add( , )); Console.WriteLine(Add(4.3, 4.4)); Console.ReadLine(); } 25

26 Tablice int[] myInts = new int[3]; myInts[0] = 100; myInts[1] = 200; myInts[2] = 300; string[] stringArray = new string[] {"raz","dwa","trzy"}; Console.WriteLine("Elementów: {0}", stringArray.Length); bool[] boolArray = { false, false, true }; Console.WriteLine("Elementów: {0}", boolArray.Length); int[] intArray = new int[4] { 20, 22, 23, 0 }; Console.WriteLine("Elementów: {0}", intArray.Length); Console.WriteLine(); 26

27 Tablice typu var Tablice obiektów Console.WriteLine("=> Implicit Array Initialization."); var a = new[] { 1, 10, 100, 1000 }; Console.WriteLine("a is a: {0}", a.ToString()); var b = new[] { 1, 1.5, 2, 2.5 }; Console.WriteLine("b is a: {0}", b.ToString()); var c = new[] { "hello", null, "world" }; Console.WriteLine("c is a: {0}", c.ToString()); Console.WriteLine(); object[] myObjects = new object[4]; myObjects[0] = 42; myObjects[1] = false; myObjects[2] = new DateTime(2012, 12, 22); myObjects[3] = "Form & Void"; foreach (object obj in myObjects) { Console.WriteLine("Type: {0}, Value: {1}", obj.GetType(), obj); } 27

28 Tablica postrzępiona (jagged array) static void JaggedMultidimensionalArray() { int[][] myJagArray = new int[5][]; for (int i = 0; i < myJagArray.Length; i++) myJagArray[i] = new int[i + 7]; for (int i = 0; i < 5; i++) { for (int j = 0; j < myJagArray[i].Length; j++) Console.Write(myJagArray[i][j] + " "); Console.WriteLine(); } Console.WriteLine(); }

29 Typy wyliczeniowe enum EmpType : byte { Manager = 10, Grunt = 1, Contractor = 100, VicePresident = 999 } static void Main(string[] args) { EmpType emp = EmpType.Contractor; AskForBonus(emp); Console.ReadLine(); Console.WriteLine("emp is a {0}.",emp.ToString()); // Wypisze "Contractor = 100". Console.WriteLine("{0} = {1}", emp.ToString(), (byte)emp); } static void AskForBonus(EmpType e) { switch (e) { case EmpType.Manager: Console.WriteLine(A może akcje?"); break; case EmpType.Grunt: Console.WriteLine(Bardzo zabawne..."); break; case EmpType.Contractor: Console.WriteLine(Ty zdzierco..."); break; case EmpType.VicePresident: Console.WriteLine(TAK JEST!); break; } 29

30 Struktury struct Point { public int X; public int Y; public void Increment() { X++; Y++; } public Point(int xP, int yP) { X = xP; Y = yP; } public void Display() { Console.WriteLine("X = {0}, Y = {1}", X, Y); } 30 static void Main(string[] args) { Point myPoint; myPoint.X = 349; myPoint.Y = 76; myPoint.Display(); myPoint.Increment(); myPoint.Display(); Console.ReadLine(); }

31 Inne sposoby pracy z typami (możliwe w C#) Typy wartościowe zawierające typy referencyjne ( struct zawierające class ) Przekazywanie typów referencyjnych przez wartość ( public void Metoda(Person p) { … } ) Przekazywanie typów referencyjnych przez referencje ( ref ) Wiele innych 31

32 Typy nullable, operator ?? int? nullableInt = 10; double? nullableDouble = 3.14; bool? nullableBool = null; char? nullableChar = 'a'; int?[] arrayOfNullableInts = new int?[10]; // compile-time error: string? s = "oops"; int? jakasLiczba = Metoda() ?? 100; // jeżeli Metoda() zwróci coś o wartości NULL, wtedy (i tylko wtedy) przypisz wartość 100 do jakasLiczba 32

33 Część V: Klasy, obiekty, etc. 33

34 Przykład klasy class Car { public string petName; public int currSpeed; public void PrintState() { Console.WriteLine ("{0} jedzie {1} kmh.", petName, currSpeed); } public void SpeedUp(int delta) { currSpeed += delta; } class Program { static void Main(string[] args) { Car myCar = new Car(); myCar.petName = "Audi"; myCar.currSpeed = 10; for (int i = 0; i <= 10; i++) { myCar.SpeedUp(5); myCar.PrintState(); } Console.ReadLine(); } 34

35 this public int currSpeed; public Car(int currSpeed) { currSpeed = currSpeed; } VS: public Car(int currSpeed) { this.currSpeed = currSpeed; } 35

36 this – wskazanie na konstruktor class Motorcycle { public int power; public string driverName; public Motorcycle() { } public Motorcycle(int intensity) : this(intensity, "") { } public Motorcycle(string name) : this(0, name) { } public Motorcycle(int pow, string name) { if(pow > 10) { pow = 10; } power = pow; driverName = name; } Motorcycle c = new Motorcycle(5); najpierw wykona się najniższy konstruktor (czyli Motorcycle(int pow, string name) ), dopiero potem ten, który przyjmuje int (z powodu konstrukcji: " : this(intensity, ) { } " 36

37 Konstruktor z domyślnymi parametrami (.NET 4.0) public Motorcycle(int power = 0, string name = "") { if (power > 10) { power = 10; } this.power = intensity; driverName = name; } 37

38 static class Motorcycle { public static int ileMotocykli; public static int liczbaStworzonychObiektow() { return ileMotocykli; } Dostępne z poziomu klasy, nie obiektu – wszystkie nowe obiekty współdzielą jedną wersję pól statycznych / metod statycznych w ramach swojej klasy. Tylko metody statyczne i pola statyczne mogą być używane wewnątrz metod statycznych – nie mają one dostępu do zwykłych pól, bo te nie istnieją na tym poziomie (żadnego this! ). 38

39 Programowanie obiektowe (OOP) Czyli co należy znać już od dawna: dziedziczenie polimorfizm hermetyczność używanie obiektów innej klasy w jeszcze innym obiekcie (jeszcze innej klasy), etc. virtual override sealed abstract 39

40 Modyfikatory dostępu public private ( domyślny ) protected internal (domyślny ) protected internal 40

41 Właściwości ( properties ) class Employee{ private string empName; private int empID; private float currPay; public string Name { get { return empName; } set { if (value.Length > 30) Console.WriteLine("Przekroczony limit znakow."); else empName = value; } } public int ID { get { return empID; } set { empID = value; } } public float Pay { get { return currPay; } set { currPay = value; } } 41

42 Właściwości (seq.) modyfikatory dostępności: public string SSN { get { return empSSN; } protected set { empSSN = value; } } tylko do odczytu: public string SSN { get { return empSSN; } } automatyczne: class Car { public string PetName { get; set; } public int Speed { get; set; } public string Color { get; set; } } 42

43 Inicjalizator obiektów class Punkt { public int X { get; set; } public int Y { get; set; } public Punkt(int xVal, int yVal) { X = xVal; Y = yVal; } public Punkt() { } public void ShowData() { Console.WriteLine("[{0}, {1}]", X, Y); } Punkt finalPoint = new Punkt { X = 30, Y = 30 }; Punkt finalPoint2 = new Punkt() { X = 30, Y = 30 }; Punkt pt = new Punkt(10, 16) { X = 100, Y = 100 }; //no i jakie teraz będą współrzędne? finalPoint.ShowData(); Console.ReadLine(); 43

44 Inicjalizator obiektów (seq.) class Punkt { public int X { get; set; } public int Y { get; set; } public PointColor Color { get; set; } public Punkt(int xVal, int yVal) { X = xVal; Y = yVal; } public Punkt() { } public Punkt(PointColor ptColor) { Color = ptColor; } public Punkt() : this(PointColor.BloodRed){ } public void ShowData() { Console.WriteLine("[{0}, {1}]", X, Y); } … Punkt goldPoint = new Punkt(PointColor.Gold) { X = 90, Y = 20 }; 44

45 Stałe const public const double Pi = 3.14; const string napis = "NAPIS"; readonly public readonly double PI; … public Klasa() { PI = 3.14; } także: static dodane do powyższych - o ile potrzebujemy stałych statycznych (np. aby móc na nich operować wewnątrz metod statycznych). 45

46 Część VI: Dziedziczenie i polimorfizm 46

47 Dziedziczenie class Samochod { public readonly int limit; private int currSpeed; public Samochod(int max) { limit = max; } public Samochod() { limit = 55; } public int Speed { get { return currSpeed; } set { currSpeed = value; if (currSpeed > limit) { currSpeed = limit; } class Ciezarowka : Samochod { } 47

48 Dziedziczenie (seq.) Brak wielokrotnego dziedziczenia klas (działa dla interfejsów) SEALED – zamknięcie dalszego dziedziczenia z klasy, którą poprzedzimy właśnie rozkazem sealed Załóżmy, że klasa nadrzędna ma 5 pól public arg1 - arg5, dziedzicząca dodała własne arg6, wtedy konstruktor dziedziczącej, żeby się nie powtarzać może wyglądać tak: public Dziedziczaca(int arg1, int arg2, int arg3, string arg4, string arg5, double arg6) : base (arg1, arg2, arg3, arg4, arg5) { pole6 = arg6; } 48

49 Typy zagnieżdżone class Zewnetrzna { public class Wewnetrzna { } private class JeszczeJednaWewnetrzna { } } Cechy: Kontrola takiej klasy (zagnieżdżonej) dostęp do private typ pomocniczy 49

50 Polimorfizm: virtual, override, etc. class Przyklad { private int dane = 1; public virtual void Stats() { Console.WriteLine(dane); } class Inna : Przyklad { private int inneDane = 10; public override void Stats() { Console.WriteLine(inneDane); } Bez słów virtual/override – wystąpi ostrzeżenia środowiska i kompilatora, ale tylko ostrzerzenie (program wciąż można kompilować). Można użyć słówka new jako słowa środowiskowego: odczep się, wiem co robię – jest to tzw. cieniowanie składowych. public override sealed void Stats () { … } 50

51 abstract Dla klas, które nie mają być tworzone (jako obiekty), ale " tylko " przekazywać pewną wspólną funkcjonalność dla dziedziczących (które z kolei są już tworzone jako: Obiekt = new Klasa(); W przypadku metod z klasy abstract – WYMUSZONE SĄ przeładowania ich jako override (w przeciwieństwie do przypadku samego virtual/override wewnątrz klasy nie będącej abstrakcyjną, które to rozkazy wtedy nie wymuszają niczego, tj. jeśli klasa dziedzicząca nie przeładuje takiej metody, wtedy może dojść do wywołania metody wirtualnej z klasy bazowej – niekoniecznie będzie to sensowne. Słowo abstract przed tym zabezpiecza ). Metody abstrakcyjne TYLKO w klasach abstrakcyjnych. Nie ma ciała metody, tj. zawsze konstrukcja: public abstract void Metoda ( parametry ) {} // ostatnie nawiasy konieczne, ale puste 51

52 as / is Kolo kolko = new Kolo(); Sprezyna x66 = (Sprezyna)kolko; // error, InvalidCastException Powyższą, mało bezpieczną konstrukcję można zastąpić: try { Hexagon hex = (Hexagon)frank; } catch (InvalidCastException ex) { Console.WriteLine(ex.Message); } ALBO przy użyciu słowa AS: Sprezyna x67 = kolko as Sprezyna; //a nóż-widelec się uda… if (x67 == null) {... } IS - skoro słowo as pozwala tworzyć cuda na kreacją klas, słowo is pozwala potem ogarnąć, z jakiego rodzaju obiektem (jakiej klasy) mamy do czynienia gdzieś dalej w kodzie: if ( x67 is kolko ) {... } else {... } 52

53 Klasa System.Object – pani matka WSZYSTKIEGO w języku C# public class Object { // Virtual members. public virtual bool Equals(object obj); protected virtual void Finalize(); public virtual int GetHashCode(); public virtual string ToString(); // Instance level, non-virtual members. public Type GetType(); protected object MemberwiseClone(); // Static members. public static bool Equals(object objA, object objB); public static bool ReferenceEquals (object objA, object objB); } Krótko i zwięźle: WSZYSTKO, każda klasa, dziedziczy z System.Object albo bezpośrednio, albo pośrednio. 53

54 Część VII: Strukturalna obsługa wyjątków 54

55 System.Exception – główna klasa, z której dziedziczą wyjątki public class Exception : ISerializable, _Exception { // Public constructors public Exception(string message, Exception innerException); public Exception(string message); public Exception(); // Methods public virtual Exception GetBaseException(); public virtual void GetObjectData(SerializationInfo info, StreamingContext context); // Properties public virtual IDictionary Data { get; } public virtual string HelpLink { get; set; } public Exception InnerException { get; } public virtual string Message { get; } public virtual string Source { get; set; } public virtual string StackTrace { get; } public MethodBase TargetSite { get; } } 55

56 Tworzenie własnego wyjątku Exception ex = new Exception(string.Format("{0} wylecial w powietrze!", name)); ex.HelpLink = "http://www.costam.pl"; ex.Data.Add("Czas", string.Format("Czas: {0}", DateTime.Now)); ex.Data.Add("Powod", "Bo masz pecha."); throw ex; // ręczne odpalenie wyjątku 56

57 Obsługa wyjątków try {...; //tutaj coś eksplodowało } catch (Exception e) { Console.WriteLine("Member name: {0}", e.TargetSite); Console.WriteLine("Class defining member: {0}", e.TargetSite.DeclaringType); Console.WriteLine("Member type: {0}", e.TargetSite.MemberType); Console.WriteLine("Message: {0}", e.Message); Console.WriteLine("Source: {0}", e.Source); Console.WriteLine("Stack: {0}", e.StackTrace); Console.WriteLine("Help Link: {0}", e.HelpLink); Console.WriteLine("\n-> Custom Data:"); if (e.Data != null) { foreach (DictionaryEntry de in e.Data) Console.WriteLine("-> {0}: {1}", de.Key, de.Value); } 57

58 Główne klasy wyjątków: System.Exception System.SystemException : Exception System.ApplicationException: Exception 58

59 Własne wyjątki – przykład 2 public class CarIsDeadException : ApplicationException { private string messageDetails = String.Empty; public DateTime ErrorTimeStamp { get; set; } public string CauseOfError { get; set; } public CarIsDeadException() { } public CarIsDeadException(string message, string cause, DateTime time) { messageDetails = message; CauseOfError = cause; ErrorTimeStamp = time; } public override string Message { get { return string.Format("Car Error Message: {0}", messageDetails); } } WYRZUCENIE WYJĄTKU: CarIsDeadException ex = new CarIsDeadException (string.Format("{0} wybuchl!", name), Bo masz pecha", DateTime.Now); ex.HelpLink = "http://www.allegro.pl"; throw ex; 59

60 Jeszcze lepiej: [global::System.Serializable] public class CarIsDeadException : ApplicationException { public CarIsDeadException() { } public CarIsDeadException(string message) : base(message) { } public CarIsDeadException(string message, Exception inner) : base(message, inner) { } protected CarIsDeadException( System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) : base(info, context) { } public DateTime ErrorTimeStamp { get; set; } public string CauseOfError { get; set; } public CarIsDeadException(string message, string cause, DateTime time) : base(message) { CauseOfError = cause; ErrorTimeStamp = time; } 60

61 Obsługa wielu wyjątków try {... } catch (CarIsDeadException e) { Console.WriteLine(e.Message); } catch (ArgumentOutOfRangeException e) { Console.WriteLine(e.Message); } catch (Exception e) { Console.WriteLine(e.Message); } finally { myCar.CrankTunes(false); } 61

62 Corrupted State Exceptions (.NET 4.0) …czyli tam, gdzie zaczynają się prawdziwe problemy a gdzie słońce już nie dochodzi. System.Runtime.ExceptionServices ->.NET 4.0 SDK manual class Program { //bez tego CSE nie zostanie wyłapane: [HandledProcessCorruptedStateExceptions] static int Main(string[] args) { try { //poniższa metoda uruchamia główny program: RunMyApplication(); } catch (Exception ex) { //ten kod niewiele naprawia, ale przynajmniej mówi, na co umarł: Console.WriteLine("Bring out your dead!!! : {0}", ex.Message); return -1; //nawet DOS to zrozumie – etykieta %ERROR% } return 0; //normal program termination } 62

63 Część VIII: Czas życia obiektów 63

64 Garbage Collector Tworzenie obiektów – przez działanie CLR Brak słowa delete, można przypisać null referencji, ale… (c.d.) GC: podział obiektów na generacje 0 – 2, w zależności od tego, jak długo już są w pamięci. W.NET 4.0 trochę inaczej działa GC niż w 1.0 – 3.5, optymalizacja czyszczenia generacji 0 i generacji 1 64

65 Metody z System.Gc AddMemoryPressure() RemoveMemoryPressure() Collect() CollectionCount() GetGeneration() GetTotalMemory() MaxGeneration() SuppressFinaliza() WaitForPendingFinalizers() e.g.: GC.GetGeneration(refToObject)); 65

66 Garbage Collector (seq.) GC.Collect(); //razem z: GC.WaitForPendingFinalizers(); public enum GCCollectionMode{ Default, //Forced Forced, //collect it now Optimized //decide when } protected virtual void Finalize() // w System.Object class Klasa { protected override void Finalize() { } //compile-time error ~Klasa() { //destruktor (C++) } 66

67 Interfejs IDisposable public interface IDisposable { void Dispose(); } Przykład: class JakasKlasa : IDisposable { public void Dispose() { //clean } Wywołanie: static void Main(string[] args) { JakasKlasa obiekt = new JakasKlasa(); if (obiekt is IDisposable) { obiekt.Dispose(); } 67

68 Rozkaz using JakasKlasa rw = new JakasKlasa(); try {... } finally { rw.Dispose(); } I tak dla każdego obiektu?… zgroza. Lepiej: static void Main(string[] args) { // Dispose() is called automatically using (JakasKlasa rw = new JakasKlasa()) { //... } 68

69 Finalize + Dispose (a raczej LUB) class JakasKlasa : IDisposable { ~JakasKlasa() { //czyści i dezynfekuje //nie wywoływać Dispose() po tym } public void Dispose() { //nie wywoływać Finalize po tej metodzie //(bo po co?), a więc: GC.SuppressFinalize(this); } 69

70 A najlepiej tak: class Klasa : IDisposable { private bool disposed = false; public void Dispose() { CleanUp(true); GC.SuppressFinalize(this); } private void CleanUp(bool disposing) { if (this.disposed == false) { if (disposing) { // Czyszczenie obiektów z pamięci } // Resztę czyścić tutaj } disposed = true; } ~Klasa() { CleanUp(false); } 70

71 Rise!!! (and eat brains) public class BaseObj { protected override void Finalize() { Application.ObjHolder = this; } class Application { static public Object ObjHolder; // Defaults to null } Powyższa metoda WSKRZESZA obiekt. Z tym, że może nam wyjść zombie – jeśli jego podobiekty już naprawdę-naprawdę nie istnieją, a nasz ożywieniec się do nich odwoła – Exception mamy jak w banku (cypryjskim). 71

72 Sztuka nieśmiertelności c.d. public class BaseObj { protected override void Finalize() { Application.ObjHolder = this; GC.ReRegisterForFinalize(this); } Ten obiekt jest nieśmiertelny. Implikacje programistyczne mogą być takie same jak społeczne – totalny bajzel, o ile nie będziemy bardzo ostrożni. 72

73 class (.NET 4.0) class (.NET 4.0) Stwórz obiekt, ale w sumie, to go nie twórz. Przynajmniej nie do czasu, aż cokolwiek będzie chciało go użyć: private Lazy mojObiekt = new Lazy (); Poniższe: private Lazy mojObiekt = new Lazy ( () => { return new Klasa(); } ); zawiera wyrażenie Lamba, do obsługi delegata (typu, a jakże: generycznego), który umożliwia zdefiniowanie, którym konstruktorem obiekt ma być utworzony. Pytania? 73

74 Część: IX: Interfejsy 74

75 Przykład class Program { static void Main(string[] args) { // wszystkie 3 klasy obiektów dziedziczą z interfejsu IClonable: string myStr = "Hello"; OperatingSystem unixOS = new OperatingSystem(PlatformID.Unix, new Version()); System.Data.SqlClient.SqlConnection sqlCnn = new System.Data.SqlClient.SqlConnection(); // więc ich trzy obiekty mogą być posłane w te samą metodę: CloneMe(myStr); CloneMe(unixOS); CloneMe(sqlCnn); Console.ReadLine(); } private static void CloneMe(ICloneable c) { object theClone = c.Clone(); Console.WriteLine("Klon: {0}", theClone.GetType().Name); } 75

76 W interfejsie: żadnych pól mogą prototypy właściwości (properties), czyli tylko: int Punkt { get; set; } żadnych konstruktorów- żadnych implementacji metod wszystkie domyślnie public abstract nie dziedziczą z bazowych ukrytych, choć mogą jawnie z innych bazowych interfejsów Interfejsy definiują pewne wspólne funkcjonalności, które wszystkie klasy dziedziczące muszą implementować. 76

77 Dziedziczenie, weryfikacja dziedziczenia z jednego interfejsu z wielu interfejsów z klasy bazowej i interfejsu(ów) static void Main(string[] args) { Kolo c = new Kolo(); IPunkt itfPt = null; try { itfPt = (IPunkt)c; Console.WriteLine(itfPt.Points); } catch (InvalidCastException e) { Console.WriteLine(e.Message); } Console.ReadLine(); } 77

78 as / is ponownie Kolo kolko = new Kolo(); IPointy inter = kolko as IPointy; if (kolko != null){... } else {... } lub: Kolo kolko = new Kolo(); if (kolko is IPointy){... } else {... } 78

79 Zastosowania interface – parametry wejściowe metody interface – zwracany przez metodę tablica interfejsów – tj. (jak wyżej z resztą) obiektów klas implementujących danych (wspólny) interfejs implementacja w VS 2010: zwykła i jawna (wymuszona) hierarchia interfejsów: dziedziczenie funkcjonalności metod abstrakcyjnych interfejsów nadrzędnych 79

80 Interfejsy IEnumerable / IEnumerator IEnumerable: public interface IEnumerable { IEnumerator GetEnumerator(); } IEnumerator: public interface IEnumerator { bool MoveNext (); // następna pozycja kursora object Current { get;} // pobierz element z kursora void Reset (); // kursor na pierwszą pozycję } Magic word: yield 80

81 IClonable public interface ICloneable { object Clone(); } Od programisty zależy, czy to będzie prawdziwa, głęboka kopia (deep-copy, innymi słowy wszystko, łącznie z obiektami potomnymi), czy tylko płytka (shallow-copy) 81

82 IComparable (np. dla funkcji Sort() ) public interface IComparable { int CompareTo(object o); } Na przykład: int IComparable.CompareTo(object obj) { Car temp = obj as Car; if (temp != null) { if (this.CarID > temp.CarID) return 1; //cokolwiek >0 – obiekt po aktualnym if (this.CarID < temp.CarID) return -1; //cokolwiek mniej niż zero: obiekt przed aktualnym else return 0; //te same obiekty } else throw new ArgumentException("!!!!"); } 82

83 IComparer interface IComparer { int Compare(object o1, object o2); } na przykład: int IComparer.Compare(object o1, object o2) { Car t1 = o1 as Car; Car t2 = o2 as Car; if (t1 != null && t2 != null) return String.Compare(t1.name, t2.name); else throw new ArgumentException("!!!"); } zwracanie jako własciwość: public static IComparer SortByPetName { get { return (IComparer)new PetNameComparer(); } } 83

84 Część X: Kolekcje, typy generyczne 84

85 System.Collections (non-generic) ArrayList (: IList, ICollection, IEnumerable, IClonable) Hashtable (: IDictionary, ICollection, IEnumerable, IClonable) Queue (FIFO) (: ICollection, IEnumerable, IClonable) SortedList (: IDictionary, ICollection, IEnumerable, IClonable) Stack (LIFO) (: ICollection, IEnumerable, IClonable) 85

86 Wady wolniejsze niż nowe, typu generic; niezbyt bezpieczne, przechowują System.Object, więc za każdym razem trzeba się martwić, czy to co wyciągamy z kolekcji na pewno jest odpowiedniego typu; już od.NET 2.0 weszły kolekcje generyczne, więc warto się w końcu przestawić; Konkluzja: omijać szeroki łukiem, używać System.Collections.Generic (to samo, tylko lepiej, szybciej, taniej) 86

87 Przykład stosowania Przykład stosowania static void UseGeneric() { List morePeople = new List (); morePeople.Add(new Person("Jan", "Nowak", 30)); Console.WriteLine(morePeople[0]); List moreInts = new List (); moreInts.Add(1); moreInts.Add(2); int sum = moreInts[0] + moreInts[1]; // Compile-time error: // moreInts.Add(new Person()); } 87

88 Interfejsy kolekcji z pakietu System.Collections.Generic ICollection IComparer IDictionary IEnumerable IEnumerator IList ISet 88

89 Klasy System.Collections.Generic Dictionary List LinkedList Queue SortedDictionary SortedSet Stack pakiet System.Core: HastSet 89

90 Inicjalizacja obiektów: int[] myArrayOfInts = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; List myGenericList = new List { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; ArrayList myList = new ArrayList { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; List myListOfPoints = new List { new Point { X = 2, Y = 2 }, new Point { X = 3, Y = 3 }, new Point(PointColor.BloodRed){ X = 4, Y = 4 } }; 90

91 List List people = new List () { new Person {FirstName= "Homer", LastName="Simpson", Age=47}, new Person {FirstName= "Marge", LastName="Simpson", Age=45}, new Person {FirstName= "Lisa", LastName="Simpson", Age=9}, new Person {FirstName= "Bart", LastName="Simpson", Age=8} }; Console.WriteLine("Items in list: {0}", people.Count); foreach (Person p in people) Console.WriteLine(p); Console.WriteLine("\n->Inserting new person."); people.Insert(2, new Person { FirstName = "Maggie", LastName = "Simpson", Age = 2 }); Console.WriteLine("Items in list: {0}", people.Count); Person[] arrayOfPeople = people.ToArray(); for (int i = 0; i < arrayOfPeople.Length; i++) { Console.WriteLine("First Names: {0}",arrayOfPeople[i].FirstName); } 91

92 List wynik Items in list: 4 Name: Homer Simpson, Age: 47 Name: Marge Simpson, Age: 45 Name: Lisa Simpson, Age: 9 Name: Bart Simpson, Age: 8 ->Inserting new person. Items in list: 5 First Names: Homer First Names: Marge First Names: Maggie First Names: Lisa First Names: Bart 92

93 Stack Stack stackOfPeople = new Stack (); stackOfPeople.Push(new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }); stackOfPeople.Push(new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }); stackOfPeople.Push(new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }); Console.WriteLine("First person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); Console.WriteLine("\nFirst person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); Console.WriteLine("\nFirst person item is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); try { Console.WriteLine("\nnFirst person is: {0}", stackOfPeople.Peek()); Console.WriteLine("Popped off {0}", stackOfPeople.Pop()); } catch (InvalidOperationException ex) { Console.WriteLine("\nError! {0}", ex.Message); } 93

94 Stack wynik First person is: Name: Lisa Simpson, Age: 9 Popped off Name: Lisa Simpson, Age: 9 First person is: Name: Marge Simpson, Age: 45 Popped off Name: Marge Simpson, Age: 45 First person item is: Name: Homer Simpson, Age: 47 Popped off Name: Homer Simpson, Age: 47 Error! Stack empty. 94

95 Queue Queue peopleQ = new Queue (); peopleQ.Enqueue(new Person { FirstName = "Homer", LastName = "Simpson", Age = 47 }); peopleQ.Enqueue(new Person { FirstName = "Marge", LastName = "Simpson", Age = 45 }); peopleQ.Enqueue(new Person { FirstName = "Lisa", LastName = "Simpson", Age = 9 }); Console.WriteLine("{0} is first in line!", peopleQ.Peek().FirstName); GetCoffee(peopleQ.Dequeue()); try{ GetCoffee(peopleQ.Dequeue()); } catch (InvalidOperationException e) { Console.WriteLine("Error! {0}", e.Message); } 95

96 Queue wynik Homer is first in line! Homer got coffee! Marge got coffee! Lisa got coffee! Error! Queue empty. 96

97 SortedSet class SortPeopleByAge : IComparer { public int Compare(Person firstPerson, Person secondPerson) { if (firstPerson.Age > secondPerson.Age) return 1; if (firstPerson.Age < secondPerson.Age) return -1; else return 0; } private static void UseSortedSet() { SortedSet setOfPeople = new SortedSet (new SortPeopleByAge()) { new Person {FirstName= "Homer", LastName="Simpson", Age=47}, new Person {FirstName= "Marge", LastName="Simpson", Age=45}, new Person {FirstName= "Lisa", LastName="Simpson", Age=9}, new Person {FirstName= "Bart", LastName="Simpson", Age=8}}; foreach (Person p in setOfPeople) { Console.WriteLine(p); } Console.WriteLine(); setOfPeople.Add(new Person { FirstName = "Saku", LastName = "Jones", Age = 1 }); setOfPeople.Add(new Person { FirstName = "Mikko", LastName = "Jones", Age = 32 }); foreach (Person p in setOfPeople) { Console.WriteLine(p); } 97

98 SortedSet wynik Name: Bart Simpson, Age: 8 Name: Lisa Simpson, Age: 9 Name: Marge Simpson, Age: 45 Name: Homer Simpson, Age: 47 Name: Saku Jones, Age: 1 Name: Bart Simpson, Age: 8 Name: Lisa Simpson, Age: 9 Name: Mikko Jones, Age: 32 Name: Marge Simpson, Age: 45 Name: Homer Simpson, Age: 47 98

99 Tworzenie swoich własnych Tworzenie swoich własnych np. dla podmiany ze sobą referencji obiektów/struktur DOWOLNEGO typu: static void Swap (ref T a, ref T b) { T temp; temp = a; a = b; b = temp; } static void DisplayBaseClass () { Console.WriteLine("Base class of {0}: {1}.", typeof(T), typeof(T).BaseType); } Wywołanie: bool b1 = true, b2 = false; Swap(ref b1, ref b2); Lepiej jednak tak (większa jaśność dla innych): Swap (ref b1, ref b2); 99

100 Część XI: Delegates, events, Lambda expressions 100

101 Garść teorii Do tego miejsca metody coś robiły po tym, jak się je kopnęło, w ten czy inny sposób. Idea delegatów i zdarzeń jest taka, żeby metody mogły reagować zwrotnie, tj. same powodować pewne zachowania całego programu, jeśli zaistnieją pewne warunki (dajmy na to: startowe). Delegat to obiekt, który przechowuje informacje o: metodach, do których ma się odwołać w razie konieczności ich parametrach wejściowych (typy) ich paramterach wyjściowych (typy) 101

102 public delegate string MyDelegate(bool a, bool b, bool c); Zmienia się w: sealed class MyDelegate : System.MulticastDelegate { public string Invoke(bool a, bool b, bool c); public IAsyncResult BeginInvoke(bool a, bool b, bool c, AsyncCallback cb, object state); public string EndInvoke(IAsyncResult result); } 102

103 Przykład: public delegate int BinaryOp(int x, int y); public class SimpleMath { public static int Add(int x, int y) { return x + y; } public static int Subtract(int x, int y) { return x - y; } } class Program { static void Main(string[] args) { BinaryOp b = new BinaryOp(SimpleMath.Add); Console.WriteLine(" is {0}", b(10, 10)); Console.ReadLine(); } 103

104 lista parametrów delagata oraz metod, które zawiera musi się zgadzać i to dokładnie wyświetlanie zawartości: static void DisplayDelegateInfo(Delegate delObj) { foreach (Delegate d in delObj.GetInvocationList()) { Console.WriteLine("Method Name: {0}", d.Method); Console.WriteLine("Type Name: {0}", d.Target); } 104

105 Dodawania i odejmowanie metod do delegata poprzez np. operatory += oraz -= ; konstrukcja delegatów wspiera generyczność: po ludzku, możliwa konstrukcja jak np. : public delegate void MyGenericDelegate (T arg); 105

106 Events { public delegate void CarEngineHandler(string msg); public event CarEngineHandler Exploded; public event CarEngineHandler AboutToBlow; } Najpierw należy określić delegata, który będzie przetrzymywać metody, które należy wywołać. Następnie określamy zdarzenia (events), które zamierzamy odpalić (z parametrami zdefiniowanymi jak w delegacie, czyli np. > Exploded("wybuchłem…); ) Po odpaleniu eventu, odpalany jest delegat, który wykonuje metody, które ma w sobie zawarte, z parametrami jakie dostał event (dlatego musi być zgodność między nimi). 106

107 Część XII: Indeksery, przeładowanie operatorów 107

108 Indeksery, przykład PeopleCollection myPeople = new PeopleCollection(); myPeople[0] = new Person("Homer", "Simpson", 40); myPeople[1] = new Person("Marge", "Simpson", 38); myPeople[2] = new Person("Lisa", "Simpson", 9); myPeople[3] = new Person("Bart", "Simpson", 7); myPeople[4] = new Person("Maggie", "Simpson", 2); for (int i = 0; i < myPeople.Count; i++) { Console.WriteLine("Person number: {0}", i); Console.WriteLine("Name: {0} {1}", myPeople[i].FirstName, myPeople[i].LastName); Console.WriteLine("Age: {0}", myPeople[i].Age); Console.WriteLine(); } 108

109 Przykład, c.d. Jak zdefiniować indekser dla poprzedniego przykładu? public class PeopleCollection : IEnumerable { private ArrayList arPeople = new ArrayList(); public Person this[int index] { get { return (Person)arPeople[index]; } set { arPeople.Insert(index, value); } } 109

110 Indeksowanie po typie string public class PeopleCollection : IEnumerable { private Dictionary listPeople = new Dictionary (); public Person this[string name] { get { return (Person)listPeople[name]; } set { listPeople[name] = value; } } IEnumerator IEnumerable.GetEnumerator() { return listPeople.GetEnumerator(); } } czyli w ten sposób: Person homer = myPeople["Homer"]; Console.WriteLine(homer.ToString()); 110

111 indeksery mogą być przeładowane, tj. kilka różnych dla tego samego obiektu, np. ideksowanie zarówno po liczbach porządkowych jak i po string mogą być używane wielowymiarowo: public class SomeContainer { private int[, ] my2DintArray = new int[10, 10]; public int this[int row, int column] { /* get / set odpowiednio skonstruowane */ } } indeksery mogą być definiowane w interfejsach, aby klasy dziedziczące implementowały odpowiednie metody indeksujące 111

112 Przeciążenie operatorów Przykład: public static Point operator +(Point p1, Point p2) { return new Point(p1.X + p2.X, p1.Y + p2.Y); } Zawsze public, zawsze static (i trzeba to wprost wpisywać w kodzie) Kolejność parametrów jest ważna przy wywoływaniu (o ile są różnych typów) Możliwe dla operatorów unarnych (e.g. +, -, ~, !, ++, --), binarnych (+, -, *, /, itd.) i innych Operatory = i != ; ; MUSZĄ być przeładowane razem w kodzie (i jeden, i drugi). Niemożliwe dla [], () oraz operatorów skróconych, tj. np. -=, +=, *=, itd. 112

113 Część XIII: Wielowątkowość 113

114 And now… the delegates (again) Delegaty mogą wywoływać metody asynchronicznie Załóżmy, że mamy delegata: public delegate int BinaryOp(int x, int y); Dla niego tworzony jest (niejawnie) obiekt klasy: public sealed class BinaryOp : System.MulticastDelegate { public BinaryOp(object target, uint functionAddress); public void Invoke(int x, int y); public IAsyncResult BeginInvoke(int x, int y, AsyncCallback cb, object state); public int EndInvoke(IAsyncResult result); } 114

115 Delegaci, asynchroniczność, c.d. Gdy delegat z przykładu zostanie aktywowany, metoda Invoke wykona się synchronicznie, tj. główny wątek aplikacji zostanie zatrzymany do czasu, aż wszystko co delegat miał wykonać, zostanie wykonane. Na przykład (dalszy slajd) w momencie aktywacji delegata zawierającego metodę, która między innymi wstrzymuje główny wątek aplikacji, wszystkie kolejne polecenia kodu muszą czekać, aż delegat skończy pracować. 115

116 Na początek: synchronicznie static void Main(string[] args) { Console.WriteLine("***** Synch Delegate Review *****"); Console.WriteLine("Main() invoked on thread {0}.", Thread.CurrentThread.ManagedThreadId); BinaryOp b = new BinaryOp(Add); // Could also write b.Invoke(10, 10): int answer = b(10, 10); Console.WriteLine("Doing more work in Main()!"); Console.WriteLine(" is {0}.", answer); Console.ReadLine(); } static int Add(int x, int y) { Console.WriteLine("Add() invoked on thread {0}.", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(5000); return x + y; } 116

117 No więc co z tą asynchronicznością?? Delegat z przykładu (każdy w zasadzie) ma automatycznie wygenerowane 2 tajemnicze metody: public IAsyncResult BeginInvoke(int x, int y, AsyncCallback cb, object state); public int EndInvoke(IAsyncResult result); Gdzie IAsyncResult to interfejs, dzięki któremu zarządza się wynikiem (a dokładnie oczekiwaniem nań): public interface IAsyncResult { object AsyncState { get; } WaitHandle AsyncWaitHandle { get; } bool CompletedSynchronously { get; } bool IsCompleted { get; } } 117

118 Najłatwiej tak: static void Main(string[] args) { Console.WriteLine("***** Async Delegate Invocation *****"); Console.WriteLine("Main() invoked on thread {0}.", Thread.CurrentThread.ManagedThreadId); // Invoke Add() on a secondary thread. BinaryOp b = new BinaryOp(Add); IAsyncResult iftAR = b.BeginInvoke(10, 10, null, null); Console.WriteLine("Doing more work in Main()!"); int answer = b.EndInvoke(iftAR); Console.WriteLine(" is {0}.", answer); Console.ReadLine(); } Linia int answer = b.EndInvoke(iftAR); odpowiada za to, żeby nie kazać głównemu wątkowi wyświetlić wyniku, jeśli go jeszcze nie ma (w przykładzie to raczej nie jest trudne, ale jeśli np. w delegacie będzie zadanie ściągnięcia pół giga kontrabandy z internetu, to już może trochę potrwać…) 118

119 Jak stwierdzić, czy delegat skończył? Problem oczywiście jest taki, że wciąż program może w przykładzie marnować czas, jeśli między wywołaniem delegata a oczekiwaniem na wynik (EndInvoke) zadania skończą się wcześnie, tak więc można użyć: BinaryOp b = new BinaryOp(Add); IAsyncResult iftAR = b.BeginInvoke(10, 10, null, null); while(!iftAR.IsCompleted) { Console.WriteLine("Doing more work in Main()!"); Thread.Sleep(1000); } int answer = b.EndInvoke(iftAR); 119

120 Oddzwonimy do pana, jak skończymy… Jeszcze inaczej: while (!iftAR.AsyncWaitHandle.WaitOne(1000, true)) { Console.WriteLine("Doing more work in Main()!"); } Jeszcze inteligentniej (=jeszcze trudniej) – a może by tak oprócz wątku głównego aplikacji (1), w trakcie pracy którego asynchronicznie robi coś delegat w wątku (2), zaprząc do pracy TRZECI wątek (3), który będzie sprawdzać co robi (2), i jak stwierdzi, że (2) skończył, da informację (1), że ma jakieś wyniki do obsłużenia ? Można oczywiście: 120

121 public delegate int BinaryOp(int x, int y); class Program { private static bool isDone = false; static void Main(string[] args) { BinaryOp b = new BinaryOp(Add); IAsyncResult iftAR = b.BeginInvoke(10, 10, new AsyncCallback(AddComplete), null); while (!isDone) { Thread.Sleep(1000); Console.WriteLine("Working...."); } Console.ReadLine(); static int Add(int x, int y) { Thread.Sleep(5000); return x + y; } static void AddComplete(IAsyncResult itfAR) { Console.WriteLine("Your addition is complete"); isDone = true; } 121

122 C.d. Poprzedni obiekt KLASY AsyncCallback nie miał dostępu do delagata, który miał monitorować – robił tylko za posłańca z wiadomością, że monitorowany obiekt skończył. Aby uzyskać dostęp do monitorowanego delagata (i jego wyników) należy użyć takiej metody AddComplete() dla poprzedniego przykładu: static void AddComplete(IAsyncResult itfAR) { AsyncResult ar = (AsyncResult)itfAR; //rzutowanie BinaryOp b = (BinaryOp)ar.AsyncDelegate; Console.WriteLine(" is {0}.", b.EndInvoke(itfAR)); isDone = true; } 122

123 Stan obiektu IAsyncResult iftAR = b.BeginInvoke(10, 10, new AsyncCallback(AddComplete),null); mamy ostatni tajemniczy null pod koniec. Definicja metody to: public IAsyncResult BeginInvoke(int x, int y, AsyncCallback cb, object state); tak więc chodzi o stan monitorowanego procesu. Dla przykładu, jeśli wywołanie delegata to: IAsyncResult iftAR = b.BeginInvoke(10, 10, new AsyncCallback(AddComplete), "Dzięki za dodanie tych dwóch liczb"); Wtedy możemy to odtworzyć poprzez: static void AddComplete(IAsyncResult itfAR) {... string msg = (string)itfAR.AsyncState; Console.WriteLine(msg); isDone = true; } 123

124 Prawdziwa wielowątkowość: System.Threading Przykład kilku właściwości obiektu z Thread: static void Main(string[] args) { Thread primaryThread = Thread.CurrentThread; primaryThread.Name = "ThePrimaryThread"; //!!!! Przydatne do debugowania Console.WriteLine("Name of current AppDomain: {0}",Thread.GetDomain().FriendlyName); Console.WriteLine("ID of current Context: {0}",Thread.CurrentContext.ContextID); Console.WriteLine("Thread Name: {0}",primaryThread.Name); Console.WriteLine("Has thread started?: {0}",primaryThread.IsAlive); Console.WriteLine("Priority Level: {0}",primaryThread.Priority); Console.WriteLine("Thread State: {0}",primaryThread.ThreadState); Console.ReadLine(); } Wynik: Name of current AppDomain: ThreadStats.exe ID of current Context: 0 Thread Name: ThePrimaryThread Has thread started?: True Priority Level: Normal // enum ThreadPriority – nie jest to obligatoryjne dla środowiska Thread State: Running 124

125 Przykład (1) Mamy drukarkę, która coś tam… drukuje (niespodzianka): public class Printer { public void PrintNumbers() { Console.WriteLine("-> {0} is executing PrintNumbers()", Thread.CurrentThread.Name); Console.Write("Your numbers: "); for (int i = 0; i < 10; i++) { Console.Write("{0}, ", i); Thread.Sleep(2000); } Console.WriteLine(); } 125

126 Główny kod: static void Main(string[] args) { Printer p = new Printer(); Thread backgroundThread = new Thread(new ThreadStart(p.PrintNumbers)); backgroundThread.Name = "Secondary"; backgroundThread.Start(); } Po ostatnim poleceniu całość działań obiektu drukarki będzie realizowana w osobnym wątku, więc jeśli będą dalsze polecenia po backgroundThread.Start(), to spokojnie się zrealizują. Ważna jest liczba rdzeni CPU! Na jednoprocesorowym komputerze program będzie bardziej responsywny, ale na pewno nie szybszy! 126

127 c.d. ThreadStart() może przyjmować tylko metody zwracające void i nie przejmujące żadnych argumentów – czyli tak trochę biednie. Przykład: class AddParams { public int a, b; public AddParams(int numb1, int numb2) { a = numb1; b = numb2; } Oraz metoda statyczna: static void Add(object data) { if (data is AddParams) { AddParams ap = (AddParams)data; Console.WriteLine("{0} + {1} is {2}", ap.a, ap.b, ap.a + ap.b); } 127

128 Realizacja wątku z poprzedniego slajdu: AddParams ap = new AddParams(10, 10); Thread t = new Thread(new ParameterizedThreadStart(Add)); t.Start(ap); // Force a wait to let other thread finish. Thread.Sleep(5); Console.ReadLine(); 128

129 Wątki pierwszo i drugoplanowe Wątki pierwszoplanowe muszą zostać (wszystkie) zakończone, aby środowisko.NET wyładowało z pamięci aplikację (np. metoda Main – dopóki jej ostatnia linia się nie wykona, aplikacja działa). Wątki drugoplanowe (czasem zwane demonami (linux?)) są kończone, jeżeli zakończył się ostatni wątek pierwszoplanowy. Na przykład: jeśli poprzez polecenie: jakiśWątek.IsBackground = true; ustawiamy drugoplanowość jakiegośWątku, to niezależnie, czy zakończył on już swoje zadanie czy nie(!), zostanie wyładowany z systemu przez środowisko.NET, jeżeli ostatni wątek pierwszoplanowy został właśnie zakończony. 129

130 Synchronizacja, czyli wszyscy na raz, a każdy co innego… public void PrintNumbers() { lock (threadLock) { Console.Write("Your numbers: "); for (int i = 0; i < 10; i++) { Random r = new Random(); Thread.Sleep(1000 * r.Next(5)); Console.Write("{0}, ", i); } Console.WriteLine(); } Załóżmy, że gdzieś w kodzie mamy private object threadLock = new Object(); służący jako token blokady, to wszystko wewnątrz kodu lock{ …} będzie wykonywane na raz dla jednego wątku. 130

131 c.d. Inaczej: jeśli poprzedni kod nie zawierałby klauzuli lock(coś) { … }, lecz tylko te polecenia co drukują liczby, wtedy, jeśli stworzylibyśmy np. 10, 20 czy 100 takich wątków i uruchomili wszystkie równocześnie, to każdy w swoim czasie coś by tam drukował, jednocześnie na tej samej konsoli. Czyli wyświetlane liczby od 1 do 10 szybko by się wymieszały na ekranie. Jeśli mamy klauzulę lock z jakimś obiektem robiącym za token, to nawet jeśli mamy 100 takich samych wątków, wtedy pierwszy, który natrafia na lock realizuje go DO KOŃCA po czym dopiero wtedy wątek drugi, trzeci i kolejne w ten sam sposób będą wykonywane. Jeszcze innymi słowy nadal są to wątki pracujące w tle, ale przynajmniej nie jeden przez drugiego, tylko w kolejności (ale ta kolejność dotyczy tylko realizacji poleceń wewnątrz lock(token) { … } ! 131

132 Lock = System.Threading.Monitor Poprzedni kod, a raczej klazula lock jest niejawnie zamienia na: public void PrintNumbers() { Monitor.Enter(threadLock); try { … } finally { Monitor.Exit(threadLock); } Lock(){} jest szybsze do zapisania, ale użycie Monitora daje dostęp do większej liczby metod, np. nakazujących czekać głównemu wątkowi, czy informujących wątki poboczne, że coś się dzieje, np. aktualny kończy pracę. 132

133 Inne formy synchronizacji System.Threading.Interlocked – dla pewnych atomowych poleceń, jak inkremencja czy dekrementacja zmiennej o 1, bezpieczne porównanie i zamiana kolejności dwóch wartości, itd. np. int zmienna = Interlocked.Increment(ref innaZmienna); Atrybut [Synchronization] Inne zagadnienia: BackgroundWorker, delegat TimeCallback, pula wątków CLR: (ThreadPool.QueueUserWorkItem(WaitCallback wcb) ) 133

134 TaskParallelLibrary (TPL).NET 4.0 Nie znaczy to, że Thread czy asynchroniczne delegaty stały się passe, i należy przestać ich używać (jak np. kolekcje bez ) – są i będą wciąż przydatne i nikt nie będzie z nich rezygnować (zbyt szybko). TPL jest po prostu wielką armatą, którą wytaczać należy tylko do NAPRAWDĘ skomplikowanych wielowątkowych algorytmów, których użycie ma szansę znacząco skrócić wykonywanie zadań. Bazuje wciąż na starych technikach tutaj zaprezentowanych, więc ich znajomość jest niezbędna w zrozumieniu TPL. 134

135 Cap. XIV: Pliki, I/O, serializacja 135

136 System.IO Ważniejsze klasy: BinaryReader BinaryWriter Directory DirectoryInfo File FileInfo FileStream FileSystemWatcher MemoryStream Path StreamWriter StreamReader StringWriter StringReader abstract FileSystemInfo: Attributes atrybuty pliku / katalogu CreationTime czas utworzenia Exists czy obiekt istnieje? Extension rozszerzenie FullName pełna ścieżka dostępu LastAccessTime ostatni dostęp LastWriteTime ostatnia modyfikacja Name nazwa pliku / katalogu 136

137 c.d. DirectoryInfo: Create() CreateSubdirectory()tworzenie katalogu lub zbioru podkatalogów Delete() kasuje katalog i całą zawartość GetDirectories() tablica obiektów DirectoryInfo o zawartości katalogu GetFiles() tablica FileInfo z zawartości katalogu MoveTo() przenoszenie do nowej ścieżki Parent zwraca katalog nadrzędny Root zwraca ścieżkę do korzenia katalogu // Bind to the current working directory. DirectoryInfo dir1 = new DirectoryInfo("."); // Bind to C:\Windows, // using a verbatim string. DirectoryInfo dir2 = new 137

138 Przykład: DirectoryInfo dir = new Console.WriteLine("***** Directory Info *****"); Console.WriteLine("FullName: {0}", dir.FullName); Console.WriteLine("Name: {0}", dir.Name); Console.WriteLine("Parent: {0}", dir.Parent); Console.WriteLine("Creation: {0}", dir.CreationTime); Console.WriteLine("Attributes: {0}", dir.Attributes); Console.WriteLine("Root: {0}", dir.Root); Console.WriteLine("**************************\n"); Wynik: ***** Directory Info ***** FullName: C:\Windows Name: Windows Parent: Creation: 7/13/ :20:08 PM Attributes: Directory Root: C:\ ************************** 138

139 Pobieranie listy plików: DirectoryInfo dir = new // pobierz wszystkie pliki jpg: FileInfo[] imageFiles = dir.GetFiles("*.jpg", SearchOption.AllDirectories); // ile znaleziono? : Console.WriteLine("Found {0} *.jpg files\n", imageFiles.Length); foreach (FileInfo f in imageFiles) { Console.WriteLine("File name: {0}", f.Name); Console.WriteLine("File size: {0}", f.Length); Console.WriteLine("Creation: {0}", f.CreationTime); Console.WriteLine("Attributes: {0}", f.Attributes); } 139

140 Tworzenie podkatalogów: DirectoryInfo dir = new dir.CreateSubdirectory("MyFolder"); DirectoryInfo myDataFolder = Console.WriteLine("New Folder is: {0}", myDataFolder); 140

141 // lista dysków: string[] drives = Directory.GetLogicalDrives(); Console.WriteLine("Here are your drives:"); foreach (string s in drives) Console.WriteLine("--> {0} ", s); // kasowanie: try { // drugie true oznacza zgodę na automatyczne kasowanie podkatalogów true); } catch (IOException e) { Console.WriteLine(e.Message); } 141

142 static void Main(string[] args) { // pobranie tablicy obiektów – napędów: DriveInfo[] myDrives = DriveInfo.GetDrives(); // wyświetlanie informacji foreach(DriveInfo d in myDrives) { Console.WriteLine("Name: {0}", d.Name); Console.WriteLine("Type: {0}", d.DriveType); // jeśli napęd jest podpięty (DVD, CD, pendrive…) if(d.IsReady) { Console.WriteLine("Free space: {0}", d.TotalFreeSpace); Console.WriteLine("Format: {0}", d.DriveFormat); Console.WriteLine("Label: {0}", d.VolumeLabel); Console.WriteLine(); } Console.ReadLine(); } 142

143 Klasa FileInfo: static void Main(string[] args) { // utworzenie nowego pliku: FileInfo f2 = new using(FileStream fs2 = f2.Open(FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)) { //.. } FileMode: CreateNew,Create,Open,OpenOrCreate,Truncate,Append FileAccess: Read,Write,ReadWrite FileShare: Delete,Inheritable,None,Read,ReadWrite,Write 143

144 FileInfo.OpenRead() FileInfo.OpenWrite() static void Main(string[] args) { FileInfo f3 = new using(FileStream readOnlyStream = f3.OpenRead()) { // FileStream object... } // tylko do zapisu: FileInfo f4 = new using(FileStream writeOnlyStream = f4.OpenWrite()) { // FileStream object... } 144

145 FileInfo.OpenText(), FileInfo.CreateText(), FileInfo.AppendText() FileInfo f5 = new using(StreamReader sreader = f5.OpenText()) { // Use the StreamReader object... } FileInfo f6 = new using(StreamWriter swriter = f6.CreateText()) { // Use the StreamWriter object... } FileInfo f7 = new using(StreamWriter swriterAppend = f7.AppendText()) { // Use the StreamWriter object... } 145

146 Klasa File using(FileStream fs = {} using(FileStream fs2 = FileAccess.ReadWrite, FileShare.None)) {} using(FileStream readOnlyStream = {} using(FileStream writeOnlyStream = {} using(StreamReader sreader = {} using(StreamWriter swriter = {} using(StreamWriter swriterAppend = {} 146

147 Inne metody klasy File ReadAllBytes() – tablica bajtów + zamknięcie pliku ReadAllLines() – tablica strings + zamknięcie pliku ReadAllText() System.String+ zamknięcie pliku Poniżej jak wyżej, tylko że zapisujemy coś: WriteAllBytes() WriteAllLines() WriteAllText() 147

148 Przykład: static void Main(string[] args) { string[] myTasks = { Naprawić kran", Zadzwonić", Zjeść coś", Zagrać w Diablo III"}; // zapis danych: myTasks); // odczyt danych foreach (string task in { Console.WriteLine("TODO: {0}", task); } Console.ReadLine(); } 148

149 FileStream // Obtain a FileStream object. using(FileStream fStream = FileMode.Create)) { // zakodowanie wiadomości jako ciągu bajtów string msg = "Hello!"; byte[] msgAsByteArray = Encoding.Default.GetBytes(msg); // zapis tablicy bajtów[] fStream.Write(msgAsByteArray, 0, msgAsByteArray.Length); // reset położenia kursora zapisu fStream.Position = 0; // odczyt od kursora Console.Write("Your message as an array of bytes: "); byte[] bytesFromFile = new byte[msgAsByteArray.Length]; for (int i = 0; i < msgAsByteArray.Length; i++) { bytesFromFile[i] = (byte)fStream.ReadByte(); Console.Write(bytesFromFile[i]); } Console.WriteLine(Encoding.Default.GetString(bytesFromFile)); } 149

150 Trochę łatwiej (i popularniej jeśli chodzi o stosowanie): StreamWriter i StreamReader using(StreamWriter writer = File.CreateText("reminders.txt")) { writer.WriteLine(Tekst pierwszy"); writer.WriteLine(Tekst drugi"); writer.WriteLine(Ciąg liczb:"); for(int i = 0; i < 10; i++) writer.Write(i + " "); // nowa linia: writer.Write(writer.NewLine); } using(StreamReader sr = File.OpenText("reminders.txt")) { string input = null; while ((input = sr.ReadLine()) != null) { Console.WriteLine (input); } 150

151 Inna wersja z poprzedniego przykładu: // zapis: using(StreamWriter writer = new StreamWriter("reminders.txt")) {... } // odczyt: using(StreamReader sr = new StreamReader("reminders.txt")) {... } 151

152 BinaryWriter i BinaryReader FileInfo f = new FileInfo("BinFile.dat"); using(BinaryWriter bw = new BinaryWriter(f.OpenWrite())) { Console.WriteLine("Base stream is: {0}", bw.BaseStream); // dane: double aDouble = ; int anInt = 34567; string aString = "A, B, C"; // zapis danych: bw.Write(aDouble); bw.Write(anInt); bw.Write(aString); } using(BinaryReader br = new BinaryReader(f.OpenRead())) { Console.WriteLine(br.ReadDouble()); Console.WriteLine(br.ReadInt32()); Console.WriteLine(br.ReadString()); } 152

153 FileSystemWatcher Klasa zawiera metody do monitorowania co się dzieje z plikiem (tadam, tadam!): asynchronicznie Np. utworzenie takiego obiektu to: FileSystemWatcher watcher = new FileSystemWatcher(); try { watcher.Path } catch(ArgumentException ex) { Console.WriteLine(ex.Message); return; } 153

154 c.d. Co ma być monitorowane i jak: // Set up the things to be on the lookout for. watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; // Only watch text files. watcher.Filter = "*.txt"; // Add event handlers. watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Created += new FileSystemEventHandler(OnChanged); watcher.Deleted += new FileSystemEventHandler(OnChanged); watcher.Renamed += new RenamedEventHandler(OnRenamed); // Begin watching the directory. watcher.EnableRaisingEvents = true; // TUTAJ INNY KOD, KTÓRY ROBI JUŻ W PROGRAMIE CO INNEGO, ALE WATCHER DZIAŁA, I JEŚLI COŚ SIĘ STANIE Z PLIKIEM CO ZOSTAŁO OKREŚLONE WYŻEJ, ODPALI SIĘ ODPOWIEDNIA Z METOD NIŻEJ: Metody: static void OnChanged(object source, FileSystemEventArgs e) { Console.WriteLine("File: {0} {1}!", e.FullPath, e.ChangeType); } static void OnRenamed(object source, RenamedEventArgs e) { Console.WriteLine("File: {0} renamed to\n{1}", e.OldFullPath, e.FullPath); } 154

155 Serializacja: Poprzednie metody zapisu i odczytu plików są ok. i powszechnie stosowane. Problem pojawia się, kiedy nieokreśloną (np. na poziomie projektowania czegoś) liczbę parametrów aplikacji trzeba będzie zapisywać, odczytywać, itd. Dla każdego parametru należałoby wtedy wprowadzać osobne linie kodu obsługujące jego zapis/odczyt. 155

156 Przykład serializacji: [Serializable] public class UserPrefs { public string WindowColor; public int FontSize; } static void Main(string[] args) { UserPrefs userData= new UserPrefs(); userData.WindowColor = "Yellow"; userData.FontSize = "50"; BinaryFormatter binFormat = new BinaryFormatter(); // zapis obiektu w pliku: using(Stream fStream = new FileStream("user.dat", FileMode.Create, FileAccess.Write, FileShare.None)) { binFormat.Serialize(fStream, userData); } Console.ReadLine(); } 156

157 Co serializować a co nie (instrukcje w kodzie, a nie porady życiowe) [Serializable] public class Radio { public bool hasTweeters; public bool hasSubWoofers; public double[] stationPresets; [NonSerialized] public string radioID = "XF-552RR6"; } [Serializable] public class Car { public Radio theRadio = new Radio(); public bool isHatchBack; } [Serializable] public class JamesBondCar : Car { public bool canFly; public bool canSubmerge; } 157

158 Kolejna informacja co będzie a co nie będzie serializowane BinaryFormatter lub SoapFormatter – te narzędzia serializują WSZYSTKO co podpada pod tag [serializable] w kodzie, tj. niezależnie czy są to pola publiczne, prywatne, publiczne właściwości prywatne, itd. XmlSerializer – trochę inaczej. Będzie serializować tylko pola publiczne a także (uwaga!) prywatne dane które zostały udostępnione jako publiczne właściwości (czyli zmienna jeśli nawet jest private, to jeśli jej właściwość get jest publiczna, zostanie przez XmlSerializer przetworzona). 158

159 [Serializable] public class Person { // A public field. public bool isAlive = true; // A private field. private int personAge = 21; // Public property/private data. private string fName = string.Empty; public string FirstName { get { return fName; } set { fName = value; } } 159

160 Różnice serializatorów BinaryFormatter – jak nazwa wskazuje, zapisuje binarnie, czyli np. liczba zapisana jest szesnastkowo, a nie w formie tekstu SoapFormatter – jako wiadomość typu SOAP (XMLowy format przesyłania wiadomości w web serviceach) XmlSerializer – XML, jak nazwa wskazuje, czyli otagowany całkowicie 160

161 Przykład serializacji binarnej: static void Main(string[] args) { JamesBondCar jbc = new JamesBondCar(); //4 slajdy wcześniej jbc.canFly = true; jbc.canSubmerge = false; jbc.theRadio.stationPresets = new double[]{89.3, 105.1, 97.1}; jbc.theRadio.hasTweeters = true; // zapis do pliku: BinaryFormatter binFormat = new BinaryFormatter(); using(Stream fStream = new FileStream("CarData.dat", FileMode.Create, FileAccess.Write, FileShare.None)) { binFormat.Serialize(fStream, jbc); } //odczyt: BinaryFormatter binFormat = new BinaryFormatter(); using(Stream fStream = File.OpenRead("CarData.dat"))) { JamesBondCar carFromDisk = (JamesBondCar)binFormat.Deserialize(fStream); Console.WriteLine("Can this car fly? : {0}", carFromDisk.canFly); } 161

162 Zapis listy obiektów [Serializable, XmlRoot(Namespace = "http://www.MyCompany.com")] public class JamesBondCar : Car { public JamesBondCar(bool skyWorthy, bool seaWorthy) { canFly = skyWorthy; canSubmerge = seaWorthy; } // XmlSerializer WYMAGA domyślnego konstruktora! public JamesBondCar(){} } 162

163 static void SaveListOfCars() { // Now persist a List of JamesBondCars. List myCars = new List (); myCars.Add(new JamesBondCar(true, true)); myCars.Add(new JamesBondCar(true, false)); myCars.Add(new JamesBondCar(false, true)); myCars.Add(new JamesBondCar(false, false)); using(Stream fStream = new FileStream("CarCollection.xml", FileMode.Create, FileAccess.Write, FileShare.None)) { XmlSerializer xmlFormat = new XmlSerializer(typeof(List )); xmlFormat.Serialize(fStream, myCars); } // LUB: static void SaveListOfCarsAsBinary() { // Save ArrayList object (myCars) as binary. List myCars = new List (); BinaryFormatter binFormat = new BinaryFormatter(); using(Stream fStream = new FileStream("AllMyCars.dat", FileMode.Create, FileAccess.Write, FileShare.None)) { binFormat.Serialize(fStream, myCars); } 163

164 ISerializable [Serializable] class StringData : ISerializable { private string dataItemOne = "First data block"; private string dataItemTwo= "More data"; public StringData(){} protected StringData(SerializationInfo si, StreamingContext ctx) { //zawsze odczytuj mały literami dataItemOne = si.GetString("First_Item").ToLower(); dataItemTwo = si.GetString("dataItemTwo").ToLower(); } void ISerializable.GetObjectData(SerializationInfo info, StreamingContext ctx) { //zawsze zapisuj dużymi literami info.AddValue("First_Item", dataItemOne.ToUpper()); info.AddValue("dataItemTwo", dataItemTwo.ToUpper()); } 164

165 Iserializable c.d. static void Main(string[] args) { StringData myData = new StringData(); SoapFormatter soapFormat = new SoapFormatter(); using(Stream fStream = new FileStream("MyData.soap", FileMode.Create, FileAccess.Write, FileShare.None)) { soapFormat.Serialize(fStream, myData); } Console.ReadLine(); } 165

166 Albo poprzez atrybuty (bez dziedziczenia z Iserializable): [Serializable] class MoreData { private string dataItemOne = "First data block"; private string dataItemTwo= "More data"; [OnSerializing] private void OnSerializing(StreamingContext context) { // Called during the serialization process. dataItemOne = dataItemOne.ToUpper(); dataItemTwo = dataItemTwo.ToUpper(); } [OnDeserialized] private void OnDeserialized(StreamingContext context) { // Called once the deserialization process is complete. dataItemOne = dataItemOne.ToLower(); dataItemTwo = dataItemTwo.ToLower(); } 166


Pobierz ppt "C#, Visual Studio 2010,.NET 4.0 dr inż. Marcin Radom Instytut Informatyki, Politechnika Poznańska laboratorium Programowania Wizualnego 1."

Podobne prezentacje


Reklamy Google