Učebnice na c#

Programovací jazyk
C#
Programové konstrukce
Ing. Marek Běhálek
Katedra informatiky FEI VŠB-TUO
A-1018 / 597 324 251
http://www.cs.vsb.cz/behalek
marek.behalek@vsb.cz
Programové konstrukce 2
Náplň kapitoly
z Typový systém
z Základní prvky jazyka
z Direktivy preprocesoru
z Jmenné prostory
z Třídy
z Pole
z Rozhraní
z Operátory
z Výjimky
z Delegáti
z …
Programové konstrukce 3
Typový systém – Základní
rozdělení
Programové konstrukce 4
Typový systém – Základní
charakteristika (1)
z C# využívá společný typový systém prostředí
.NET (CTS)
z Základní dělení je na hodnotové a referenční
typy.
z Automatická konverze z hodnotového na
referenční (boxing) a z referenčního na
hodnotový (unboxing).
z Objektově orientovaný typový systém. Vše je
objekt. Vychází z třídy System.Object.
Programové konstrukce 5
Typový systém – Základní
charakteristika (2)
z C# se snaží být čistě objektový jazyk.
z C# obsahuje hodnotové typy (ty jsou důležité zejména pro
rychlost provádění programu).
z Tento rozpor je vyřešen pomocí automatické konverze (Boxing /
Unboxing).
z V posledním kroku je vytvořena instance třídy System.Int32, do
které je hodnotová proměnná a zabalena.
object o;
SomeClass someObject = new SomeClass();
int a = 10;
o = someObject;
o = a;
Programové konstrukce 6
Typový systém – Hodnotové
typy
z Obsahují pouze hodnotu daného typu.
z Instancím hodnotového typu říkáme proměnné.
z Hodnoty tohoto typu jsou ukládány na zásobník.
z Jejich výhodou je zejména rychlost.
z Hodnotové typy musí být vždy inicializovány.
z Při přiřazení je přímo kopírována hodnota.
z Všechny hodnotové typy vycházejí z třídy System.ValueType.
z Nepodporují dědičnost.
z Hodnotové typy se dělí na:
z Základní hodnotové typy;
z Uživatelsky definované hodnotové typy – struktury, výčtové typy.
Programové konstrukce 7
Typový systém –Celočíselné
typy (1)
z sbyte (System.Sbyte) - znaménkový typ s rozsahem -128 až
+127
z byte (System.Byte) - neznaménkový typ s rozsahem 0 až 255
z short (System.Int16) - -32768 až +32767
z ushort (System.UInt16) 0 až 65535
z int (System.Int32) - 32 bitový, znaménkový celočíselný typ
z uint (System.UInt32) - 32 bitový, neznaménkový celočíselný
typ
z long (System.Int64) - 64 bitový, znaménkový celočíselný typ
z ulong (System.UInt64) - 64 bitový, neznaménkový celočíselný
typ
z Char (System.Char) - Tento typ slouží k uložení znaků v
Unicode
Programové konstrukce 8
Typový systém –Celočíselné
typy (2)
z Celočíselné konstanty lze zapisovat bud v desítkové nebo
šestnáctkové soustavě (Ox).
z Neznaménkovou konstantu lze zapsat pomocí u/U.
z Celočíselnou konstantu typu long lze vytvořit pomocí l/L.
z Pokud konstanta překročí rozsah typu ulong, jde o chybu při
překladu.
z Konstanta je vyčíslena v době překladu.
z Je nutné použít modifikátor L, jinak by došlo k přetečení.
int a = 10;
uint b = 10u;
short c = 0x0FFF;
long d = 10000L*10000L*10000L
Programové konstrukce 9
Typový systém –Celočíselné
typy (2)
z Konverze celočíselných typů
z Pokud například používáme byte dochází k automatické
konverzi na int. Musí se „explicitně“přetypovat.
z Podobně je tomu i u celočíselných konstant.
byte x = 1, y = 2, sum = 0;
sum = x + y; // nelze (operator +)
sum = (byte)(x + y); // explicitni konverze
public void MaMetoda(int x) {}
public void MaMetoda(byte x) {}
MaMetoda(3); // zavola se metoda s parametrem typu int
MaMetoda((byte)3); // zavola se metoda s parametrem typu byte
Programové konstrukce 10
Typový systém –Celočíselné
typy (3)
z Speciální je typ char
z Jazyk C# pracuje se znaky v unicode o délce 16 bitů.
z Pro hodnoty typu char neexistuje implicitní konverze na
žádný celočíselný typ.
z Znakové konstanty lze zapisovat jako:
z znak v apostrofech;
ƒ char a = ‘a’;
z jednoduchou escape sekvencí;
ƒ char b = ‘\n’;
z hexadecimální escape sekvencí;
ƒ char c = ’\x0041’;
z unicode escape sekvence.
ƒ char d = ‘\u0041’
Programové konstrukce 11
Typový systém –Celočíselné
typy (4)
z Escape sekvence v jazyce C#
z \' Apostrof 0x0027
z \” Uvozovka 0x0022
z \\ Opačné lomítko 0x005C
z \a Alert 0x0007
z \b Backspace 0x0008
z \f Form feed 0x000C
z \n New line 0x000A
z \t Horizontální tabelátor 0x0009
z \v Vertikální tabelátor 0x000B
Programové konstrukce 12
Typový systém – Reálné typy
(1)
z float (System.Single) - reálný typ s
nejmenším rozsahem přesnosti 1.5e-45 až
3.4e38, 7 desetinných míst
z double (System.Double) - 64 - bitový reálný
typ, 15-16 desetinných míst
z decimal (System.Decimal) - reálný typ s
největší přesností (128 bitový), 28-29
desetinných míst
Programové konstrukce 13
Typový systém – Reálné typy
(2)
z Neexistuje implicitní konverze mezi typem decimal
a ostatními reálnými typy.
z Reálná konstanta je implicitně typu double.
z Přípony jednoznačně určující typ jsou:
z f, F - float
z d, D - double
z m, M - decimal
float a = 1.1f;
double b= -1.1e-1;
decimal c = 1.23456789123456789M;
Programové konstrukce 14
Typový systém – Logický
hodnotový typ
z bool (System.Boolean) - typ pro ukládání
logických hodnot true, false
z Hodnotu logické proměnné lze inicializovat
pomocí true (pravda) a false (nepravda).
bool a = true;
bool b = (a!=a);
Programové konstrukce 15
Typový systém – Struktury (1)
z Uživatelsky definovaný hodnotový typ.
z Někdy také hovoříme o odlehčených třídách.
z Struktura může obsahovat:
z položky (atributy);
z metody;
z operátory;
z vlastnosti;
z indexery.
Programové konstrukce 16
Typový systém – Struktury (2)
z Od třídy se struktury zásadně liší.
z Proměnné tohoto typu jsou umístěny na zásobník.
z Struktury nepodporují dědičnost.
z Struktura se nemůže stát základem pro vytvoření nového typu.
z K položkám struktury lze přistupovat pomocí tečkového
operátoru.
struct Point
{
public int x;
public int y;
}
z Strukturu je nutné před použitím instanciovat pomocí operátoru
new.
Programové konstrukce 17
Typový systém – Struktury (3)
struct Zvirata_A_Nohy
{
int pocetNohou;
string nazevZvirete;
public Zvirata_A_Nohy(int novyPocetNohou, string
novyNazevZvirete) {
pocetNohou = novyPocetNohou;
nazevZvirete = novyNazevZvirete;
}
public int vratPocetNohou() {
return pocetNohou;
}
public string vratNazevZvirete() {
return nazevZvirete;
}
}
Programové konstrukce 18
Typový systém –Výčtový typ
(1)
z Uživatelsky definovaný hodnotový typ.
z Množina pojmenovaných konstant.
z Výčtové typy jsou deklarovány pomocí
klíčového slova enum.
z Existuje pro něřada omezení.
z Nemohou definovat své vlastní metody.
z Nemohou implementovat rozhraní.
z Nemohou definovat své indexery nebo vlastnosti.
Programové konstrukce 19
Typový systém –Výčtový typ
(2)
enum days1{Monday, Tuesday, Wednesday, Thursday,
Friday, Saturday, Sunday};
enum days2{Monday=1, Tuesday, Wednesday, Thursday,
Friday, Saturday=0, Sunday=0};
enum days3:byte{Monday, Tuesday, Wednesday,
Thursday, Friday, Saturday, Sunday};
Console.WriteLine("Today is {0}.",days2.Tuesday);
Console.WriteLine("It is {0}. day in
week.",(int)(days.Tuesday));
Výstup programu bude:
Today is Tuesday.
It is 2. day in week.
Programové konstrukce 20
Typový systém – Nullable typy
(1)
z Problém u hodnotových typů může být s null.
z Někdy null chápeme spíše jako „bez hodnoty“. Tomu
například u typu int nic neodpovídá.
z Další problém by mohl být při použití databáze a podobně.
z Řešení, které přináší C# 2.0 nový generický typ
Nullable
z Tento typ může uchovávat jak hodnotový a referenční typ.
z V jazyce přibyl nový operátor ?, který usnadňuje použití
Nullable.
Nullable a;
int? b;
Programové konstrukce 21
Typový systém – Nullable typy
(2)
z Nullable typ je struktura, která kombinuje hodnotu základního
typu s booleovským indikátorem null.
z bool HasValue - je true pro instance, které neposkytují
hodnotu typu null a false pro null instance.
z T Value - má typ podle základního typu nullable typu. Vrací
obsažený typ, nebo vyvolá výjimku.
z Existuje implicitní konverze z jakéhokoliv non-nullable typu na
nullable formu tohoto typu.
z Existuje implicitní konverze z null, na kterýkoliv nullable typ.
int? x = 123;
int? y = null;
if (x.HasValue) Console.WriteLine(x.Value);
double? y = 123; // int? --> double?
int? z = (int?)y; // double? --> int?
int j = (int)z; // int? --> int
Programové konstrukce 22
Typový systém – Referenční
typy (1)
z Uživatelsky definovaný hodnotový typ.
z Množina pojmenovaných konstant.
z Podobné ukazatelům z C ale jsou typově bezpečné.
z Instance referenčního typu je alokována na hromadě.
z Reference může mít hodnotu null.
z I další typy jsou „nullable“, více později.
z Před použitím musí být inicializovaná operátorem new.
z O uvolnění paměti se stará Garbage collector.
z Podporují jednoduchou dědičnost a polymorfismus.
z Všechny vycházejí ze třídy System.Object.
Programové konstrukce 23
Typový systém – Referenční
typy (2)
z Jazyk C# definuje tyto skupiny referenčních
typů:
z typ object – jde o alias třídy System.Object.
z typ string – slouží k uložení textových řetězců.
Jde opět o alias k třídě System.String.
z typ třída (class);
z typ rozhraní (interface);
z typ pole;
z typ delegát (delegate).
Programové konstrukce 24
Typový systém –
System.Object
z V CTS .NET Frameworku je vše objekt. Základem
každého typu je třída System.Object. Tato třída
definuje tyto metody:
z bool Equals() - tato metoda porovnává referenci
dvou objektů;
z int GetHashCode();
z Type GetType() - poskytuje informace o typu
daného objektu;
z string ToString() - tato metoda standardně
poskytuje název objektu.
Programové konstrukce 25
Typový systém –
System.String
z Slouží k uložení textových řetězců a manipulaci s
nimi.
z Třída System.String definuje množství metod a
operátorů pro práci s řetězci.
z Při porovnávání se vždy porovnávají hodnoty
objektů, tedy samotné řetězce.
string s="Some text";
s="Hello"+" "+"world";
if (s=="Hello world")
s=Console.ReadLine();
Programové konstrukce 26
Typový systém – Jednoduchý
vstup a výstup (1)
z Jednoduchý vstup a výstup programu zprostředkovává třída
System.Console. Tato třída obsahuje tyto veřejně přístupné
vlastnosti:
z Error (System.IO.TextWriter)
z Out (System.IO.TextWriter)
z In (System.IO.TextReader)
z Některé veřejné metody jsou:
z int Read() - čte další znak ze standardního vstupu nebo -1
pro konec vstupu.
z string ReadLine() - čte celý řádek ze standardního vstupu.
z Write() - tato přetížená metoda vypíše hodnotu parametru. To
může být text, číslo, ...
z WriteLine() - podobně jako Write vypíše hodnotu parametru
následovanou koncem řádku.
Programové konstrukce 27
Typový systém – Jednoduchý
vstup a výstup (1)
z Metody Write a WriteLine mohou obsahovat proměnný počet
parametrů. Pak je první parametr formátovací řetězec (typu
string). Znaky {0},{1} budou v tomto formátovacím řetězci
nahrazeny hodnotou druhého respektive třetího parametru.
Console.Write("Hola ");
Console.Out.Write("Mundo!\n");
Console.WriteLine("What is your name: ");
string name = Console.ReadLine(); //používá
namespace System
Console.WritLine("Your name is {0}.Is it really
{0}?",name);
Console.WriteLine("{0}+{1}={2}",1,2,3);
Console.WriteLine("{0}",new System.Object())
Programové konstrukce 28
Direktivy preprocesoru
z I jazyk C# umožňuje využít direktivy
preprocesoru
z #define, #undef, #if, #endif, #elif, #else.
z #pragma – zakáže či povolí výpis některých varování
z #region, #endregion – není zpracováván
preprocesorem, ale slouží Visula Studiu k definování
oblastí. Takto lze zpřehlednit zdrojový kód.
Programové konstrukce 29
Jmenné prostory (1)
z Knihovna tříd .NET Framework je uspořádána do
hierarchické struktury jmenných prostorů.
z Výsledkem může být poměrně dlouhý název.
z Pomocí příkazu using lze "připojit" nějaký jmenný prostor
(Ne třídu!).
using System;
z Příkaz using lze využít i pro definování alternativních
jmen (aliasů) tříd.
using alias = třída;
using output = System.Console;
output.Write("Hello world!");
Programové konstrukce 30
Jmenné prostory (2)
using SomeNamesapce;
using AnotherNamesapce;
namespace A
{
class Class1 {}
class Class2 {}
}
namespace B
{
namespace C
{
}
class Class1 {}
}
Programové konstrukce 31
Jmenné prostory (3)
z Jmenný prostor System obsahuje mimo jiné tyto užitečné typy
z Array -umožňuje práci s poli
z Console - práce s konzolí
z Math -třída pro matematické funkce a operace
z Random - generování náhodných čísel
z String - práce s řetězci
z DateTime - struktura pro práci s datem a časem
z System.Collections obsahuje třídy kolekcí a rozhraní pracující s
kolekcemi.
z System.IO obsahuje třídy pro souborové operace
z System.Data obsahuje třídy pro vytváření architektury datového přístupu
ADO.NET
z System.Net používá síťové operace (služby pro přístup k Internetu apod)
z System.Xml slouží pro práci s XML daty
z System.Threading pro práci s vlákny
z System.Security obsahuje třídy zajišťující bezpečnost.
Programové konstrukce 32
Třídy
z Jde o jeden z referenčních typů.
z Třída obsahuje zapouzdření dat a metod.
z Deklarace třídy:
class SomeName
{
...
}
z Jazyk C# neodděluje deklaraci a definici třídy.
Programové konstrukce 33
Třídy – Členové třídy
z Položky (field) - členské proměnné, udržují stav objektu.
z Metody - funkce implementující služby objektem poskytované.
z Vlastnosti (property) - je také označována za chytrou položku.
Navenek vypadají jako položky, ale umí kontrolovat přístup k
jednotlivým datům.
z Indexer - u některých tříd je výhodné definovat operátor [].
Indexer je speciální metoda, která umožňuje aby se daný objekt
choval jako pole.
z Operátory – v jazyce C# máme možnost definovat množinu
operátorů sloužících pro manipulaci s jejími objekty.
z Událost (event) – jejím účelem je upozorňovat na změny, které
nastaly např. v položkách tříd.
Programové konstrukce 34
Třídy – Modifikátory přístupu
z public – člen označený tímto modifikátorem je dostupné bez
omezení;
z private – člen je přístupny pouze členům stejné třídy;
z protected – přistupovat k takovému členu můžeme uvnitř vlastní
třídy a ve všech třídách, pro které je třída základem;
z internal – člen je přístupný všem v rámci jedné assembly.
z Při přiřazování modifikátorů přístupu platí tato pravidla:
z implicitně jsou položky privátní (private);
z všechny modifikátory mohou být aplikovány na libovolný člen
třídy;
Programové konstrukce 35
Třídy – Jednoduchý příklad (1)
class SomeClass
{
int someValue;
public int GetSomeValue()
{
return someValue;
}
public void SetSomeValue(int newValue)
{
someValue=newValue;
}
public static void Main() {
System.Console.WriteLine("Do nothing");
}
}
Programové konstrukce 36
Třídy – Jednoduchý příklad (2)
z Implicitně jsou členové třídy deklarovaní jako
privátní (private). Položka someValue je tedy
private.
z Modifikátor přístupu musí být explicitně použit u
každé položky (jejíž přístupová práva měníme).
z Metoda která nevrací žádnou hodnotu je uvozena
klíčovým slovem void.
z V případě, že metoda nemá žádné parametry,
obsahuje její deklarace pouze prázdné závorky.
z Aplikace je spuštěna pomocí metody Main.
Programové konstrukce 37
Třídy – Metody Main (1)
z Každá třída může obsahovat pouze jednu metodu
Main.
z V projektu může být několik tříd, které obsahují
metodu Main. To může být výhodné například pro
lazení aplikace.
z Při kompilaci je nutné zvolit jednu z tříd, které
obsahují metodu Main (Project - Project properties -
General - Statup object)
z Referenční typy je před použitím nutné instanciovat
pomocí operátoru new.
Programové konstrukce 38
Třídy – Metody Main (2)
using System;
class RunApp
{
public static void Main()
{
Console.WriteLine("Running...");
RunApp run=new RunApp();
}
}
class DebugApp
{
public static void Main()
{
Console.WriteLine("Debuging...");
}
}
Programové konstrukce 39
Třídy – Metody Main (3)
z Parametry z příkazové řádky jsou předávány jako parametr
metody Main. Jde o pole textových řetězců (string).
using System;
class SomeClass
{
public static void Main(string args[])
{
foreach(string arg in args)
{
Console.WriteLine("{0}",arg);
}
}
}
z Metoda Main může také vracet hodnotu typu int (pak je
ukončena příkazem return).
Programové konstrukce 40
Třídy – Statické a nestatické
součásti třídy (1)
z Další možný modifikátor členů třídy je static.
z Nestatická data jsou individuální pro každý objekt,
mohou používat ukazatel this.
z Statická data jsou společná pro všechny "uživatele"
třídy.
z Ke statickým položkám lze přistupovat pouze přes
název třídy, ne přes instanci.
z Statické metody mohou pracovat pouze se
statickými položkami.
z Statické položky nemohou používat ukazatel this.
Programové konstrukce 41
Třídy – Statické a nestatické
součásti třídy (2)
class SomeClass
{
static int staticValue=10;
int instanceValue;
public static void PrintValue()
{
System.Console.WriteLine("{0}",staticValue);
}
public void SetInstanceValue(int
instanceValue)
{
this.instaceValue=instanceValue;
}
}
Programové konstrukce 42
Třídy – Konstruktory (1)
z Konstruktory slouží ke korektní inicializaci objektů.
z Konstruktor je volán v době vytvoření instance
příslušného objektu.
z instance objektů jsou vytvářeny pomocí operátoru new.
z Syntaxe konstruktoru je:
[public] [static] ClassName([prametr1, ...])
z Konstruktor nemá žádný návratový typ.
z Název konstruktoru je shodný s názvem třídy.
z Jedna třída může mít více konstruktorů lišících se v
parametrech (signatuře).
z Konstruktor nesmí mít návratovou hodnotu.
Programové konstrukce 43
Třídy – Konstruktory (2)
using System;
class A
{
public A(){
Console.WriteLine("instance of
class A was created.");
}
public A(int a)
{
Console.WriteLine("{0}",a);
}
}
Programové konstrukce 44
Třídy – Konstruktory (3)
z Konstruktor bez parametrů je označován jako
implicitní konstruktor.
z Pokud nevytvoříme žádný konstruktor, je tento
implicitní konstruktor vygenerován.
z Automaticky vygenerovaný konstruktor má prázdné
tělo.
z Pokud vytvoříme nějaký konstruktor, pak
automaticky vygenerovaný není.
z Konstruktor může volat další konstruktory a to
pomocí ukazatele this.
Programové konstrukce 45
Třídy – Konstruktory (4)
class A
{
public A(int a)
{
Console.WriteLine("{0}",a);
}
public A(int a,int b):this(a)
{
Console.WriteLine("{0}",b);
}
public static void Main() {
A example1=new A(1,2);
A example2=new A();
}
}
Výstup programu bude:
1
2
Programové konstrukce 46
Třídy – Statické konstruktory
(1)
z Jazyk C# povoluje statické konstruktory.
z Musí být uvozeny klíčovým slovem static.
z Mohou pracovat pouze se statickými položkami třídy.
z Nesmí mít žádné parametry.
z Statické konstruktory nelze volat. Jsou automaticky
spuštěny před prvním "použitím" třídy
z Je-li v aplikaci více tříd se statickým konstruktorem,
pořadí jejich volaní není definováno.
Programové konstrukce 47
Třídy – Statické konstruktory
(2)
using System;
class A
{
static A()
{
Console.Write("A");
}
}
class