Učebnice na c#

B
{
static B()
{
Console.Write("B");
}
public static void Main()
{
A a;
}
}
Programové konstrukce 48
Třídy – Statické konstruktory
(3)
z Představený příklad nevypíše nic.
z Doplníme-li tělo metody Main takto:
a=new A();
z Bude výstup programu:
A
z Doplníme-li tělo metody Main takto:
a=new A();
B b=new B;
z Výstup programu není exaktně specifikován a bude bud:
AB
z nebo
BA
Programové konstrukce 49
Třídy – Destruktory
z Pro rušení objektu lze definovat destruktor. Jde o metodu s
těmito vlastnostmi:
z Název je složen z tildy(~) a jména třídy.
z Nemá návratovou hodnotu a to ani typ void.
z Nemá žádné formální parametry.
z Nelze u něj použít žádné modifikátory přístupu.
z Nemůže být přetížen.
z Nemusí být definován, pokud to není potřeba.
z class A {
~A() { //cleaning }
}
z Překladač zpracuje destruktor a interně si jej uloží jako metodu
Finalize. Destruktor volá automaticky garbage collector. Není
garantováno kdy nebo zda-li vůbec bude zavolán. Pro
deterministické uvolňování zdrojů slouží rozhraní IDisposable.
Programové konstrukce 50
Třídy – Konstanty
z Jde o členská data uvozená klíčovým slovem const.
z Jejich hodnota musí být známá v době definice.
z Konstanty jsou interně reprezentovány jako statické položky
třídy.
z Konstanty nemohou být v programu modifikovány.
class Example
{
public const double PI=3.14;
public static void Main()
{
System.Console.WriteLine(PI);
}
}
Programové konstrukce 51
Třídy – Read-only položky
z Jde o členská data uvozená klíčovým slovem readonly.
z Jejich hodnota může být naplněna v konstruktoru.
z Žádná jiná metoda nesmí tuto položku modifikovat.
z Read-only položky jsou vázány na konkrétní instanci třídy. Přístup k nim
je tedy prostřednictvím konkrétního objektu.
class Building {
public readonly int NumberOfWindows;
public Building(int NumberOfWindows) {
this.NumberOfWindows=NumberOfWindows;
}
public static void Main() {
Building myHome=new Building(10);
Console.WriteLine("Building has {0}
windows.",myHome.NumberOfWindows);
}
}
Programové konstrukce 52
Třídy – Metody
z Metody třídám dodávají funkcionalitu. Metoda má:
z jméno;
z návratovou hodnotou. Nevrací li funkce nic, je označena
klíčovým slovem void;
z libovolný počet parametrů;
z viditelnost.
class A
{
public int SomeMethod(int a,string b,object c)
{
}
}
z Deklarované metody v třídě mohou mít stejný název, musí se ale
lišit v signatuře.
Programové konstrukce 53
Třídy – Parametry metody
z Standardně jsou parametry metody předávány hodnotou.
z Funkce získává kopii skutečných parametrů.
z Jakákoliv změna hodnot parametrů se neprojeví po skončení funkce.
class A
{
public void SomeMethod(int a)
{
a=5;
}
public static void Main()
{
int a=1;
SomeMethod(a);
System.Console.WriteLine("{0}",a);
}
}
z Výstupem programu bude:
1
Programové konstrukce 54
Třídy –Předávání parametrů
odkazem
z Volající i metoda sdílí jednu proměnnou, jedno místo v paměti.
z Takové parametry označujeme klíčovým slovem ref.
z Předávané parametry musí být inicializovány.
class A
{
public void SomeMethod(ref object a)
{
a=new object();
}
public static void Main()
{
object a,b;
a=b=new object(); //a musí být inicializovaná
SomeMethod(ref a);
System.Console.WriteLine(a==b);
}
}
z Výstupem programu bude:
False
Programové konstrukce 55
Třídy – Výstupní parametry
z Volající a metoda opět sdílejí jedno paměťové místo, ale předaný
parametr je brán jako neinicializovaný.
z Takovýto parametr označujeme klíčovým slovem out.
z Výhodou oproti předávání parametrů pomocí reference je, že proměnné
nemusí být inicializovány.
class A
{
public void SomeMethod(out string a)
{
a="hello world";
}
public static void Main()
{
string a; //nemusí být inicializovaná
SomeMethod(out a);
System.Console.WriteLine(a);
}
}
z Výstupem programu bude:
hello world
Programové konstrukce 56
Třídy – Metody s proměnným
počtem parametrů (1)
z Příkladem metody s proměnným počtem parametrů
je metoda System.Console.WriteLine.
z Chceme-li deklarovat metodu s proměnným počtem
parametrů použijeme klíčové slovo params:
NávratovýTyp JménoFunkce(Typ parametr1, ... ,
params Typ[] jménoParametru) {...}
z Položka deklarující proměnný počet parametrů musí
být posledním parametrem funkce.
z Typ u položky reprezentující proměnný počet
parametrů musí vždy být pole.
Programové konstrukce 57
Třídy – Metody s proměnným
počtem parametrů (2)
using System;
class MySimpleSet
{
public void PrintIt(object[] mySet)
{
foreach(object item in mySet)
Console.Write(item+",");
Console.WriteLine();
}
public static void Main() {
PrintIt(1,1.2,"hello",new object());
PrintIt("one","two");
}
}
z Výstupem programu bude:
1,1.2,"hello",System.Object,
"one","two"
Programové konstrukce 58
Třídy –Přetěžování metod
z Jazyk C# umožňuje definovat v jedné třídě více metod stejného názvu.
z Jednotlivé metody se musí lišit v počtu parametrů, typech parametrů
nebo v počtu i typech parametrů.
z Pokud se metody liší pouze v návratovém typu, jde o chybu.
using System;
class Example
{
public void MyPrint(string text)
{
Console.WriteLine("Text: "+text);
}
public void MyPrint(int number)
{
Console.WriteLine("Number: "+number);
}
}
Programové konstrukce 59
Třídy –Dědičnost
z Vytváříme nové typy na základě existujících -
dědičnost.
z Odvozená třída obsahuje všechny položky třídy
základní.
z C# podporuje pouze jednoduchou dědičnost. Třída
tedy může rozšiřovat maximálně jednu třídu.
z V odvozené třídě máme k dispozici všechny veřejné
(public) a chráněné (protected) členy třídy základní.
z Dědičnost vyjádříme dvojtečkou uvedenou za
jménem třídy a názvem třídy základní.
Programové konstrukce 60
Třídy –Dědičnost (2)
class Point
{
protected int x,y;
public void Count() {
}
}
class Circle : Point
{
public void SomeMethod()
{
x=10;
Count()
}
}
Programové konstrukce 61
Třídy – Konstruktory v
odvozených třídách (1)
z Při vytváření objektu jsou postupně volány všechny konstruktory a to od
třídy základní až po vytvářenou třídu.
class A
{
public A()
{
Console.WriteLine("Creating A");
}
}
class B : A
{
public B()
{
Console.WriteLine("Creating B");
}
public static void Main()
{
B b=new B();
}
}
Programové konstrukce 62
Třídy – Konstruktory v
odvozených třídách (1)
z Výstup programu bude:
Creating A
Creating B
z Pokud bychom modifikovali konstruktor třídy A takto:
public A(string text)
{
Console.WriteLine("Creating A, "+text);
}
z Překlad nebude úspěšný. Implicitní konstruktor nebyl vygenerován. To,
který konstruktor rodičovské třídy bude volán, můžeme ovlivnit pomocí
klíčového slova base.
z Konstruktor třídy B tedy upravíme:
public B() : base ("Hello from B")
{
Console.WriteLine("Creating B");
}
z Výstup programu bude:
Creating A, Hello from B
Creating B
Programové konstrukce 63
Třídy –Překrytí členů třídy (1)
z Chceme-li v odvozené třídě změnit
metodu(nebo jiného člena) třídy základní,
označíme takovéhoto člena klíčovým slovem
new.
z Klíčové slovo new musí být uvedeno před
deklaraci typu metody.
z Překlad bude úspěšný i pokud klíčové slovo
new neuvedeme. Výsledkem bude warning a
"správné" chování.
Programové konstrukce 64
Třídy –Překrytí členů třídy (2)
using System;
class A
{
protected int x=10;
public void Test()
{
Console.WriteLine("Test A");
}
}
class B : A
{
protected int x=11;
//warning, správně: protected new int x=11;
public new void Test()
{
Console.WriteLine("Test B");
}
}
Programové konstrukce 65
Třídy –Překrytí členů třídy (3)
z To, která metoda případně položka třídy bude použita, je nyní
závislé na typu reference.
class RunApp
{
public static void Main()
{
B b=new B();
A a=b;
b.Test();
a.Test();
}
}
z Výstup programu bude:
Test B
Test A
Programové konstrukce 66
Třídy – Polymorfismus (1)
z Chceme, aby se volala metoda podle typu objektu a
ne reference na něj (polymorfní chování).
z Použijeme následující postup:
z Metoda, která se má chovat polymorfně, je u
základní třídy označena klíčovým slovem virtual.
z Předefinovanou metodu ve všech odvozených
třídách označíme klíčovým slovem override.
z Opět platí, že tato klíčová slova je nutné uvést před
deklarací návratového typu.
Programové konstrukce 67
Třídy – Polymorfismus (2)
using System;
class A
{
public virtual void Test()
{
Console.WriteLine("Test A");
}
}
class B : A
{
public new void Test()
{
Console.WriteLine("Test B");
}
}
class C : A
{
public override void Test()
{
Console.WriteLine("Test C");
}
}
Programové konstrukce 68
Třídy – Polymorfismus (3)
class RunApp
{
public static void Main()
{
A a=new A();
A b=new B();
A c=new C();
a.Test();
b.Test();
c.Test();
}
}
z Výstup programu bude:
Test A
Test A
Test C
Programové konstrukce 69
Třídy – Vlastnosti (1)
z Vlastnosti se navenek chovají jako veřejné členské položky,
interně jsou však tvořeny množinou přístupových metod.
class SomeClass
{
protected string propertyName;
public string PropertyName
{
get
{
Console.WriteLine("get "+this.propertyName);
return this.propertyName;
}
set
{
this.propertyName=value;
Console.WriteLine("set "+value);
}
}
}
Programové konstrukce 70
Třídy – Vlastnosti (2)
z Vynecháním metody set lze vytvořit read-only
vlastnost. Pokusíme-li se do takovéto položky
přiřadit, překladač nahlásí chybu.
z Vynecháním metody get lze vytvořit write-only
vlastnost.
z Vlastnosti nemusí být interně svázány s
konkrétní členskou položkou.
z Vlastnosti mohou být statické.
z Vlastnosti jsou interně realizovány jako metody,
lze na ně aplikovat modifikátory jako u metod
(virtual, override).
Programové konstrukce 71
Třídy – Vlastnosti (3)
class A
{
protected static string propertyName;
public virtual string PropertyName
{
get
{
return propertyName;
}
set
{
propertyName=value;
}
}
}
class B : A
{
public override string PropertyName
{
get
{
return propertyName+", hello from B";
}
}
}
Programové konstrukce 72
Třídy – Vlastnosti (4)
z Od verze jazyka 2.0 mohou mít přístupové metody get a set
nastaven modifikátor viditelnosti (public, private a nebo
protected).
public string Name
{
get
{
return name;
}
protected set
{
name = value;
}
}
Programové konstrukce 73
Třídy – Indexer (1)
z Umožňuje pracovat s typem jako s polem.
z Obecná syntaxe indexeru používá klíčové slovo this s hranatými
závorkami.
class SetOfPoints {
Point[] points;
public SetOfPoints(int size)
{
points=new Point[size];
}
public Point this[int index]
{
set
{
if (index = is as
z Rovnosti - == !=
z Logické bitové - & | ^
z Logické spojky - && ||
z Podmínečné - ?:
z Přiřazovací - = += -= *= /= %= &= |= ^= =
Programové konstrukce 94
Operátory – Primární operátory
z ( x ) - závorky, implicitně určují prioritu.
z x.y - operátor tečka realizuje přístup k členům tříd nebo struktur.
x identifikuje element ke kterému přistupujeme a y jeho člena.
z f(x) - operátor kulatých závorek obsahuje seznam parametrů pro
vyvolání metody.
z a[x] - operátor hranatých závorek slouží k indexování pole.
z x++ a x-- - inkrementace respektive dekrementace.
z new - slouží k vytvoření instance referenčního typu.
z checked a unchecked - tyto operátory zapínají respektive
vypínají kontrolu výsledků matematických operací.
z typeof - slouží k reflexi. Vrátí instanci třídy System.Type.
z sizeof - slouží k zjištění velikosti hodnotových typů. Tato operace
je považována za nebezpečnou a proto musí být tento operátor
umístěn v bloku unsafe.
Programové konstrukce 95
Operátory – Primární operátory
z Definování bloku unsafe se explicitně zříkáme
bezpečnostních kontrol prostředí .NET
z Blok je definován pomocí klíčového slova unsafe a
složenými závorkami.
z Je nutné překladači povolit unsafe bloky (Project-
Properties-Configuration Properties-Build-Allow
Unsafe Code Blocks).
unsafe
{
Console.WriteLine("Size of int:
{0}",sizeof(int));
}
Programové konstrukce 96
Operátory – Unární operátory
z + a - - operátory unárního plus a unárního
mínus. Jsou definovány pro většinu číselných
typů.
z ! - operátor logické negace. Je definován pro
typ bool.
z ~ - bitový doplněk. Je definován pro typy int,
uint, long, ulong.
z ++x, --x - inkrementace a dekrementace (v
prefixovém tvaru)
z (T)x - operátor přetypování. V případě chyby je
vygenerovaná výjimka InvalidCastException.
Programové konstrukce 97
Operátory – Aritmetické
operátory
z Jazyk C# obsahuje běžné aritmetické
operátory: +, -, *, /, %.
z Tyto operátory lze kombinovat s
operátorem přiřazení: +=, -=, ...
z Výsledkem může být:
z nějaké číslo;
z záporná nula;
z kladné nebo záporné nekonečno;
z NaN (Not a Number).
Programové konstrukce 98
Operátory – Další operátory (1)
z Operátory posuvu - slouží k realizaci bitového posuvu na
celých číslech.
z Aritmetický posun - při posuvu doprava je na pozici nejvyššího bitu
doplňována 0 pro kladná a 1 pro záporná čísla.
z Logický posun - při posuvu doleva jsou z leva doplněny nuly
int b=1-how nice-> Hello
Programové konstrukce 131
Delegáti – Kompozice delegátu
z Delegát nemusí být interně spojen pouze s jedinou metodou.
z Pomocí operátoru + a - jsem schopni delegáty "libovolně" skládat a slučovat.
class RunApp
{
static void Main(string[] args)
{
Text text=new Text("Hello");
Text.SomePrefix simplePrefix=new
Text.SomePrefix(PrefixBuilder.SimplePrefix);
PrefixBuilder prefixBuilder=new PrefixBuilder();
Text.SomePrefix nicePrefix=new
Text.SomePrefix(prefixBuilder.NicePrefix);
Text.SomePrefix greatPrefix=simplePrefix + nicePrefix +
simplePrefix;
text.WriteIt(greatPrefix);
greatPrefix-=nicePrefix;
text.WriteIt(greatPrefix);
}
}
z Výstup programu bude:
## >-how nice-> ## Hello
## ## Hello
Programové konstrukce 132
Delegáti – Anonymní metody
(1)
z Ve verzi 2.0 přibyla nová vlastnost anonymní metody.
z Anonymní metody umožňují psát kód delegátů přímo "in-line".
z Vytváří se klíčovým slovem delegate, za kterým následuje in-line
definice anonymní funkce.
z Dvě hlavní vlastnosti anonymních metod:
z vypuštění seznamu parametrů při definici anonymní funkce,
pokud tento seznam nevyužíváme.
z Seznam typových parametrů je považován za kompatibilní se všemi
delegáty kromě těch, kteřímajíout parametry.
z Parametry definující typ delegáta je nutné vždy dodat, a to ve chvíli,
kdy je delegát volán.
z využití lokálních proměnných, které jsou definovány v těle
metody, v níž je anonymní metoda umístěna.
z Takovým proměnným a parametrům říkáme vnější (outer)
proměnné. Navíc při odkazování se na tyto vnější proměnné je
nazýváme zachycené (captured).
Programové konstrukce 133
Delegáti – Anonymní metody
(2)
z Seznam parametrů delegáta je kompatibilní s
anonymní metodou pokud:
z Anonymní metoda nedefinuje seznam parametrů a delegát
nemá žádné out parametry.
z Signatura anonymní metody je shodná s delegátem.
z Návratový typ delegáta je kompatibilní s anonymní
metodou pokud platí alespoň jedno z těchto tvrzení:
z Návratový typ delegáta je void a anonymní metoda
neobsahuje žádné příkazy return anebo obsahuje pouze
return;.
z Návratový typ delegáta není void a všechny výrazy v
anonymní metodě vázané s příkazem return mohou být
implicitně přetypovány na návratový typ delegáta.
Programové konstrukce 134
Delegáti – Anonymní metody
(3)
delegate double Function(double x);
static double[] Apply(double[] a, Function f)
{
double[] result = new double[a.Length];
for (int i = 0; i < a.Length; i++)
{
result[i] = f(a[i]);
}
return result;
}
double[] a = {0.0, 0.5, 1.0};
a=Apply(a,delegate(double x){return x * x;});
Programové konstrukce 135
Delegáti – Anonymní metody
(4)
delegate double Function(double x);
static double[] Apply(double[] a, Function f) {
double[] result = new double[a.Length];
for (int i = 0; i < a.Length; i++)
result[i] = f(a[i]);
return result;
}
z Anonymní metoda, která používá vnější proměnné.
static double[] MultiplyAllBy(double[] a, double factor)
{
return Apply(a, delegate(double x) { return
x * factor; });
}
z Vypuštění parametrů v definici anonymní funkce:
Apply(a, delegate{return 0.0;});
z Za klíčovým slovem delegate není ani složená závorka. Ta by definovala, že seznam
parametrů je prázdný,
Programové konstrukce 136
Delegáti – Konverze
skupinových metod
z Anonymní metoda může být implicitně přetypována na
kompatibilní delegátský typ.
z C# 2.0 dovoluje stejný způsob konverze i pro skupinu metod.
z Dovoluje explicitním konkretizacím delegátů, aby byly ve všech
případech vynechány.
z Místo:
addButton.Click += new EventHandler(AddClick);
Apply(a, new Function(Math.Sin));
z Můžeme použít:
addButton.Click += AddClick;
Apply(a, Math.Sin);
Programové konstrukce 137
Delegáti – Události (1)
z Zpracování událostí je v zásadě proces, kdy jeden
objekt dokáže upozornit další objekty na to, že došlo
k nějaké změně (události). Systém událostí v jazyce
C# interně využívá delegátů. Na tyto delegáty jsou
kladeny tyto podmínky:
z delegát musí mít dva parametry a oba jsou objekty;
z první udává kdo je zdrojem události;
z druhý obsahuje informace spojené s konkrétní událostí.
Tento objekt musí rozšiřovat třídu EventArgs.
z Využití delegátu a událostí demonstruje následující
příklad.
Programové konstrukce 138
Delegáti – Události (2)
z Pokud událost generuje nějaké argumenty, které potřebují posluchači
pro korektní zpracování událostí, může je předat prostřednictvím
druhého parametru.
z Ten musí rozšiřovat třídu EventArgs.
z V našem případě třída bude mít navíc text, který obsahuje informace o
vygenerované události.
class InfoEventArgs : EventArgs
{
private string info;
public InfoEventArgs(string info)
{
this.info=info;
}
public string Info
{
get {return info;}
}
}
Programové konstrukce 139
Delegáti – Události (Zdroj
událostí)
class Producer
{
string name;
public Producer(string name)
{
this.name=name;
}
public string Name
{
get {return name;}
}
public delegate void WantToKnow(Producer source,InfoEventArgs args);
public event WantToKnow ItemProduced;
public void Produce(string productName)
{
Console.WriteLine("Production of "+productName+" started.");
InfoEventArgs info=new InfoEventArgs(productName);
Console.WriteLine("Production of "+productName+" ended.");
if (ItemProduced!=null) ItemProduced(this,info); //vyvolání události
}
}
Programové konstrukce 140
Delegáti – Události (3)
z Předcházející příklad ukazuje jak lze implementovat zdroj
událostí.
z Nejprve je definice typ delegátu WantToKnow, ten má
požadovaný formát.
z Nevrací žádnou hodnotu, první parametr je zdroj událostí a druhý
třída rozšiřující EventArgs.
z Jde o naši předpřipravenou třídu InfoEventArgs.
z Následuje definice události. Událost je deklarovaná klíčovým
event. Následuje typ delegáta, který může být posluchačem
události a jméno události.
z V našem příkladě je událost pojmenovaná ItemProduced.
z V případě, že potřebujeme vyvolat událost. Použijeme podobný
způsob jako bych