Vývojové prostředky AutoCADu

• Základy jazyka C#
• Základy objektově orientovaného programování
• Direktivy preprocesoru
• Datové typy
• Hodnotové typy
• Struktury
• Proměnné
• Operátory
• Třídy
• Pole
• Cykly

Základy jazyka C#

Jazyk C# vyvinula firma Microsoft. Byl představen spolu s celým vývojovým prostředím .NET. Jak název napovídá, vychází tento jazyk v mnohém z programovacího jazyka C/C++, ale v mnoha ohledech je daleko bližší programovacímu jazyku Java. Základní charakteristiky jazyka jsou: Překladače jazyka C# jsou case sensitive. Rozlišují tedy velká a malá písmena

Základy OOP

Charakteristické rysy objektově orientovaného programování

Charakteristickými rysy objektově orientovaného programování (OOP) jsou použití tříd, zapouzdření a polymorfismus. OOP slouží k urychlení tvorby výsledné aplikace. Splnění požadavku urychlení tvorby aplikace pomáhají: V prostředí OOP je možné se setkat s následujícími pojmy:

Abstrakce

Označuje skutečnost, že třídu je možné chápat jako černou skříňku. Nezajímá nás co je uvnitř pouze jak se to ovládá zvenčí. Členské funkce Označení funkcí patřící jedné metodě. Členské funkce implementují chování objektů třídy.

Dědičnost

Jazyk C++ umožňuje tvorbu datové struktury, která dědí vlastnosti od jiné datové struktury a poté doplnit do vytvářené struktury jedinečné vlastnosti. Struktury, které dědí data a funkce od jiných struktur jsou uspořádány v hierarchii dědičnosti. Takto napsaný kód není pouze sám opětovně použitelný, ale opětovně použitelné jsou i datové struktury (třídy) obsahující proměnné a funkce. Odvozené třídy (potomci) mohou převzít vlastnosti (datové složky i metody) rodičovské třídy. Odvozená třída blíže specifikuje rodičovskou třídu. Například rodičovskou třídou může být třída ovoce a odvozenou třídou potom pomeranč. Jedním ze základních principů OOP je, že potomek (instance odvozené třídy) může vždy zastoupit předka (instanci rodičovské třídy). Pro náš příklad to znamená, že pomeranč je ovoce. (Pozor obrácený vztah neplatí, objekt rodičovské třídy nemůže zastoupit objekt odvozené třídy. Neplatí, že každé ovoce je pomeranč.)

Instance

Jiné označení pro objekt, jedná se o proměnnou nebo konstantu typu třída.

Objekt

Objektem se označují objekty reálného světa, které slouží jako vzor třídám, stejně i jako instance tříd (objektových typů) nebo oblast paměti, s kterou lze manipulovat (konstanty, proměnné, funkce...).

Polymorfismus

Při práci s různými objekty provádíme podobné operace (např. kreslíme objekt). Často se ale stane, že postup vykreslování objektů je zcela odlišný (nejenom počtem a typem parametrů - jako je tomu u přetěžování). Při psaní takového programu se stane, že v době deklarace funkce neznáme typ instance, s kterou bude pracovat (viz dědičnost). C++ tuto deklaraci umožňuje pomocí použití polymorfismu. Funkci deklarujeme v nadřazené třídě objektů jako virtuální a až teprve v jednotlivých objektech (potomcích) ji implemntujeme. Při vykreslování objektu program zajistí, že je vyvolána správná funkce. Poznámka - někdy bývá označováno i přetěžování funkcí za druh polymorfismu.

Předefinování

Pojem předefinování úzce souvisí s polymorfismem. Předefinování funkce znamená, že je funkce znovu definovaná v odvozené třídě (aby správně reagovala na své volání). Předefinovaná funkce musí být v rodičovské třídě deklarována jako virtuální.

Přetěžování (overloading) funkcí

Přetěžování = definice více funkcí se stejným identifikátorem (jménem). Funkce se od sebe rozlišují pomocí počtu a typu parametrů. Přetěžování (overloading) operátorů Obdoba přetěžování funkcí. Přetížení operátorů znamená rozšíření operátoru na uživatelem definované typy (výčtové a objektové). Rozlišení operace, kterou má překladač uskutečnit je opět pomocí počtu a typu parametrů. Typickým příkladem přetíženého operátoru je operátor +. Jsou li použity jako operandy čísla, jedná se o matematickou operaci sčítání. Jsou-li ale použity jako operandy řetězce, jedná se o operaci složení.

Rozhraní (interface)

Prostředek pro výměnu informací mezi třídami, funkcemi, moduly...

Zapouzdřenost

Reálné objekty jsou v programu složeny ze svých vlastností (data) a chování (metody). Vlastnosti a metody zastřešuje (zabaluje) třída, která je reprezentuje konkrétními hodnotami.

zapouzdření dat poznámka:
Jeden C# soubor může obsahovat i více deklarací tříd, na rozdíl od Java programu. Deklarace jedné třídy nebo struktury může být rozložena do více souborů., tzv. "partial classes"

Direktivy preprocesoru

Podobně jako v jazyce C/C++ i jazyk C# umožňuje využít několik direktiv preprocesoru a tak řídit předzpracování zdrojového kódu. Direktivy preprocesoru začínají znakem: #. Existuje celá řada různých direktiv #define, #undef, #if, #endif, #elif, #else. Pomocí nich lze ovlivnit, které části kódu budou zpracovávány. Další zajímavou direktivou preprocesoru je #pragma. Ta umožňuje zakázat či povolit vypisování některých varovných hlášení. Velice užitečná je direktiva #region a #endregion. Ty jsou preprocesorem ignorovány, ale využívá jich například Visual Studio 2005. Umožňují definovat oblasti v kódu. Tyto pak umí VS formátovat (zabalit, rozbalit). Takto zpřehledňují vytvořený zdrojový program.

Datové typy

Jazyk C# (podobně jako jiné programovací jazyky v prostředí .NET Framework) využívá společný typový systém CTS. Jazyk sám žádné speciální, s ostatními jazyky nekompatibilní, typy nepřináší. Typový systém je rozdělen do dvou hlavních kategorií: Obrázek 3.1. Základní typy

1. Hodnotové typy

Instance hodnotových typů (proměnné) jsou ukládány na zásobník programu a program s nimi pracuje přímo. Hodnotové proměnné, jak napovídá jejich název, obsahují pouze hodnotu proměnné daného typu bez jakýchkoliv doplňujících informací. Hodnotové typy v jazyce C# lze dále rozdělit do tří kategorií: základní typy, struktury a výčtové typy.

1.1. Primitivní datové typy

Základní typy se příliš neliší od jiných programovacích jazyků.

1.1.1. Celočíselné datové typy



Tabulka 3.1. Primitivní datové typy celočíselné

Při přiřazování hodnot proměnným nesmíme zapomenout na to, jak se v C# s čísly zachází. Pokud pracujeme s typem byte, nelze napříkad jednotlivé proměnné typu byte sčítat bez explicitní konverze do byte. byte x = 1, y = 2, sum = 0; sum = (byte)(x + y); // explicitni konverze

1.1.2. Reálné datové typy a typ decimal



Tabulka 3.2. Reálné datové typy a typ decimal

1.2 Struktury

Struktury jsou vlastně uživatelsky definovaným hodnotovým typem. Je to jakási odlehčená třída. Od tříd se ale liší. Proměnné typu struktura jsou umístěny na zásobník, struktury nepodporují dědičnost a struktura sama se nemůže stát základem pro vytvoření nového typu. Struktury jsou logickým sdružením atributů, metod, vlastností, indexerů, operátorů, a případně dalších vnořených typů. Struktury mohou mít definovány dokonce i konstruktory.

Když máme takto vytvořenou strukturu a chceme ji někde použít, je třeba vytvořit její instanci pomocí operátoru new .

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;
}
}

1.3. Výčtové typy

Výčtové typy se hodí pro celočíselné konstanty. Právě díky tomu, že každé položce ve výčtovém typu můžeme přiřadit i jejich hodnoty. Dokonce lze dvěma položkám přiřadit stejnou hodnotu a C# si potom vybere jednu hodnotu jako primární (z důvodů reflexe a řetězcových konverzí). Výčtové typy mají následující omezení:
• nemohou definovat své vlastní metody
• nemohou implementovat rozhraní
• nemohou definovat své indexery nebo vlastnosti



enum DnyVTydnu {
neděle, pondělí, úterý, středa, čtvrtek, pátek, sobota
};


Proměnné

deklarace:
datový_typ identifikátor;

příklad: int i;

Kompilátor nás nenechá použít tuto proměnnou bez inicializace. Pro proměnnou alokuje 4 byty. Inicializujeme pomocí operátoru přiřazení =:
i = 10;
Nebo naráz:
int i = 10;
Několik proměnných stejného datového typu:
int x = 10, y =20; // x a y jsou typu int

C# považuje neinicializovanou proměnnou za chybu.
• Členské proměnné tříd, pokud nejsou inicializovány explicitně, jsou nastaveny na nulovou (default) hodnotu
• Lokální proměné metod musí být inicializovány explicitně
Životnost
• Členská proměnná třídy existuje po dobu existence objektu
• Lokální proměnné existují po dobu vykonávání bloku kódu
• Proměnné deklarované ve smyčkách existují po dobu vykonávání bloku smyčky
Konstanty
const int a = 100; // hodnotu nelze měnit
• Musí být deklaraci inicializovány
• Musí být vyčíslitelné v čase kompilace. Nelze inicializovat výrazem, použijte read-only field
• Jsou implicitně statické

Operátory

Množina operátorů v jazyce C# je až na pár výjimek identická s operátory v jiných programovacích jazycích.



Tabulka 4.1. tabulka priority operátorů

Příklady
• typeof - slouží k reflexi. Vrátí instanci třídy System.Type
Type t = typeof(Console);
foreach(MemberInfo info in t.GetMembers()) Console.WriteLine(info);
• 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.


Definování bloku unsafe se explicitně zříkáme bezpečnostních kontrol prostředí .NET. Blok je definován pomocí klíčového slova unsafe a složenými závorkami. Je nutné překladači povolit unsafe bloky.


// compile with: /unsafe
class Program
{
unsafe
static void Main(string[] args)
{
}
int size = sizeof(int);
Console.WriteLine(size);
Console.ReadLine();
}
}



• Při porovnávání stringů pomocí operátoru == je porovnávána hodnota. Pokud chceme porovnat reference, musíme alespoň jeden řetězec přetypovat.



string a="hello";
string b="hello";
string c=String.Copy(a);
Console.WriteLine(a==c); //True
Console.WriteLine((object)a==(object)b); //True,same constant.
Console.WriteLine((object)a==(object)c); //False


Operátory is a as


• Pomocí operátoru is jsme schopni zjistit, zda je daný prvek instancí dané třídy, případně implementuje-li dané rozhraní



string a="hello";
if (someObject is SomeInterface) //vrátí true v případě, že someObject implementuje dané rozhraní
{
return someObject;
}
else
{
return null;
}



• Operátor as provádí přetypování na daný typ. Pokud přetypování není možné, vrací null. return someObject as SomeInterface;

Třídy

Třídou se v C# rozumí programová datová struktura. Třída může obsahovat tyto členy:
1. položky (field) – členské proměnné, udržují stav objektu
2. metody – jde o funkce, které implementují služby objektem poskytované. Každá metoda má návratovou hodnotu, pokud nic nevrací, je označena klíčovým slovem void. V jazyce C# lze přetěžovat metody. Přetížené metody se musí lišit v počtu parametrů, v typu parametrů nebo v obojím. Výjimečná metoda je statická metoda s názvem Main. Právě pomocí této metody je projekt spouštěn. Je-li v projektu definováno více metod Main, je nutné při kompilaci zadat jako parametr jméno jedné třídy z těchto tříd. Metoda Main této třídy je pak spuštěna. Každá třída může obsahovat maximálně jednu metodu Main;
3. vlastnost (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;
4. 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;
5. operátory – v jazyce C# máme možnost definovat množinu operátorů sloužících pro manipulaci s jejími objekty;
6. událost (event) – jejím účelem je upozorňovat na změny, které nastaly např. v položkách tříd.

U jednotlivých členů třídy můžeme použít modifikátory přístupu. Modifikátor je nutné aplikovat na každého člena zvlášť. Jeho uvedení není povinné, implicitní hodnota je private. Možné modifikátory jsou:

1. public – člen označený tímto modifikátorem je dostupné bez omezení;
2. private – člen je přístupny pouze členům stejné třídy;
3. 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;
4. internal – člen je přístupný všem v rámci jedné assembly.

Dalším možným modifikátorem je modifikátor static, pomocí něj lze deklarovat, že je daný člen třídy statický. Uvnitř nestatických metod třídy můžeme použít klíčové slovo this, to reprezentuje referenci objektu na sebe sama.

Metody a parametry

Parametry jsou obvykle předávány do metody hodnotou. Funkce získá kopii skutečných parametrů a jakékoliv modifikace uvnitř těla metody se nepromítnou zpět. V jazyce C# máme dvě řešení.
1. Předání parametru odkazem. Metoda si nevytváří vlastní kopii, nýbrž přímo modifikuje proměnnou, která ji byla předána. Takovéto parametry označíme klíčovým slovem ref. Předávané parametry musí být inicializovány.
2. Definovat parametry jako výstupní. Takové parametry označíme klíčovým slovem out. Parametry pak přenášejí své hodnoty směrem ven z metody. Hlavním rozdílem oproti předávání parametrů odkazem je, že předané proměnné nemusí být inicializovány před voláním metody. Uvnitř těla funkce je brán parametr jako neinicalizovaný.

Ukázka kódu
class Test
{
public void Swap(ref int a, ref int b){
int tmp;
tmp=a;
a=b;
b=tmp;
}
public void GetXY(Point somePoint,out int x, out int y){
x=somePoint.GetX();
y=somePoint.GetY();
}
public static void Main()
{
int a=5,b=3;
Swap(ref a,ref b);
GetXY(new Point(1,2),out a,out b);
}
}


V jazyce C# musí být každá funkce metodou třídy. Pokud potřebujeme samostatné funkce, můžeme vytvořit statické metody třídy. Takové jsou např. elementání funkce třídy System.Math nebo metoda WriteLine třídy System.Console: Console.WriteLine("sin({0})={1}",x,Math.Sin(x));

Metoda s proměnným počtem parametrů

Chceme-li definovat metodu s proměnným počtem parametrů, využijeme klíčové slovo params. To musíme uvést před posledním parametrem. Typ tohoto parametru musí být pole.
public void someMethod(params object[] p); //deklarace metody s proměnným počtem parametrů

Konstruktory a destruktory

Konstruktor nevrací žádnou hodnotu (ani void). Každá třída má definovaný implicitně konstruktor bez parametrů a s prázdným tělem. Každý objekt by pak měl být vytvořen pomocí operátoru new. Jiným typem konstruktoru je tzv. statický konstruktor. Pomocí něj lze inicializovat statické položky. Jiné položky pomocí tohoto typu konstruktoru inicializovat nelze. Tento konstruktor nesmí mít žádné parametry a je vyvolán ještě před vytvořením prvního objektu. Pro statické konstruktory dále platí, že jsou spouštěny v náhodném pořadí. Nelze se tedy v jednom spoléhat na druhý.
class Point
{
static short dimension;
short x=0
private short y=0;

public Point()
{
}
public Point(short nx, short ny)
{
x=nx;
y=ny;
}
static Point()
{ //statický konstruktor
dimension=2;
}
static void Main()
{
Point a = new Point();
Point b = new Point(1,2);
}
}

Chceme-li zavolat konstruktor stejné třídy, můžeme to udělat pomocí klíčového slova this. Syntaxi demonstruje následující příklad.

public Point(Point p):this (p.GetX(), p.GetY())

{

{


Destruktor má název začínající tildou (~) následovaný jménem třídy. Od konstruktoru se liší tím, že nesmí mít žádné formální parametry a nemůže být přetížen. Pokud to není nutné, nemusí být definován.

Dědičnost a polymorfismus

Představuje jeden ze základních rysů objektově orientovaného programování. Dědění tříd umožňuje definovat nové třídy na základě tříd, které již existují. Třídy, od kterých odvozujeme nové třídy jsou nazývány rodičovské třídy. Odvozené třídy jsou označovány jako potomci nebo dceřiné třídy. Skupiny provázaných tříd (vztahem předek-potomek) jsou nazývány dědické hierarchie.

Odvozená třída "zdědí" vlastnosti svých předků - bude obsahovat všechny nestatické datové složky svých předků a bude moci používat jejich metody, typy a statické složky (pokud jí to dovolí přístupová práva).

Dědění se využívá v OOP pro vyjádření specifikace: Předek popisuje abstraktnější pojem, zatím co potomek popisuje konkrétnější, přesněji vymezený pojem

Jazyk C# definuje pouze jednoduchou dědičnost. Dědičnost v definici třídy vyjádříme dvojtečkou uvedenou za jménem třídy a názvem základní třídy. Pro metody odvozené třídy pak platí:
• chceme-li předefinovat veřejnou metodu třídy kterou dědíme, musíme použít klíčové slovo new. V tomto případě záleží na typu reference, jaká metoda se zavolá;
• chceme-li realizovat polymorfismus, použijeme virtuální metody. Postup je následující: metodu základní třídy označíme jako virtuální (klíčové slovo virtual) a metodu v odvozené třídě označíme klíčovým slovem override (má se chovat polymorfně).
class A
{
public void SomeMethod()
{
}
public virtual void AnotherMethod()
{
}
}
class B : A
{
public new void SomeMethod()
{
//původní metoda je překryta
}
public override void AnotherMethod()
{
}
}
class Run
{
static void Main()
{
A a=new B();
a.SomeMethod(); //spustí původní metodu třídy A
a.AnotherMethod(); //spustí metodu třídy B
}
}


Konstruktory v odvozených třídách

Chceme-li volat konstruktor základní třídy v odvozené třídě, můžeme k tomu využít klíčové slovo base. Syntaxi demonstruje následující příklad:
Ukázka kódu
public SomeName(…):base(…){ … }

Pole

Pole chápeme jako množinu proměnných stejného datového typu. S takovým polem pak zacházíme jako s celkem. Na jednotlivé prvky pole (proměnné) se můžeme odkazovat pomocí jejich indexů pole a poté s nimi pracovat jako s obyčejnými proměnnými. Každý počáteční prvek pole v C# má index 0, pokud tedy máme pole délky N, index posledního prvku bude N-1.

Deklarace pole

V C# existují dva způsoby, jak deklarovat pole. První ze způsobů více naznačuje objektovost polí. Ten si ukážeme jen "ve zkratce", více se budeme zabývat druhým, klasickým a určitě i praktičtějším způsobem. Jazyk C# umožňuje vytvořit instanci pole pomocí statické metody System.Array.CreateInstance(). Tento způsob více odpovídá objektové charakteristice tvorby objektů.
Ukázka kódu
using System; ... Array pole = Array.CreateInstance(typeof(int), 4); Vytvořili jsme instanci třídy Array typu int se čtyřmi prvky. Pokud budeme toto pole chtít naplnit, nemůžeme již k jednotlivým prvkům přistupovat pomocí indexů, jako jsme byli zvyklí u běžných polí. Je třeba k těmto prvkům přistupovat pomocí metod SetValue() a GetValue().
Ukázka kódu
... pole.SetValue(3, 0); // na nultou pozici pole vlozime cislo 3 Console.WriteLine(pole.GetValue(0)); // vytiskneme 0. prvek pole ... Stejným způsobem, ale i s možností přistupovat k jednotlivým prvkům pole pomocí indexů, můžeme tehdy, pokud vytvoříme pole druhou (následující) konstrukcí. První způsob tedy opustíme.
Pro jednorozměrná pole v jazyce C# platí deklarace:
typ[] nazev_pole;

Vícerozměrná pole

Pokud chceme deklarovat vícerozměrné pravidelné pole, píšeme nejprve typ pole, následují hranaté závorky, do kterých napíšeme pouze čárky podle toho, kolikarozměrné pole chceme používat. Příklad: Deklarace 2-rozměrného pole s názvem pole typu int
Ukázka kódu
int[,] pole = new int[2,2] { {2, 1}, {4, 3} }; Vícerozměrná nepravidelná pole V jazyce C# lze používat i nepravidelná pole. Nepravidelná pole se vyznačují různou délkou jednotlivých "řádků" pole. Pokud například chceme vytvořit pole, které má v prvním řádku 3 prvky a v druhém 2 prvky, provedeme to následovně:
Ukázka kódu
int[][] pole; pole = new int[2]; pole[0] = new int[3]; pole[1] = new int[2];

Přístup k jednotlivým prvkům pole se pak provádí následovně: pole[0][0] nám vrátí hodnotu prvku v první řadě a prvním sloupci.

Kopírování polí

Místo obvykle používaného cyklu pro kopírování pole x do pole y:
Ukázka kódu
for(int i=0; i<=x.Length; i++) y[i] = x[i];
lze použít metodu CopyTo() dostupnou všem polím
Ukázka kódu
CopyTo() x.CopyTo(y,0);
První parametr udává cílové pole, do kterého se má kopírovat druhý parametr udává počáteční index, na který se bude ukládat. Pokud cílové pole od daného počátečního indexu nebude dostatečně dlouhé, vyvolá se výjimka.

Podmíněné příkazy

Příkaz if
Má stejnou syntaxi jako v ostatních programovacích jazycích.


if (podmínka)

statement(s)

else

statement(s)

Více příkazů se musí uzavřít do bloku {}. Pro jeden příkaz nemusíme požívat závorky.

Příkaz switch...case

Příkaz if je přehledný, pokud testujeme dvě podmínky. Pak se stává nepřehledným. Příkaz switch používáme pro testování více vstupních podmínek. Jeho zápis je ve tvaru:
switch (vyraz) {
case hodnota1 :
prikazy;
break;
case hodnota2 :
prikazy;
break;
...
default : prikazy;
}




Cykly

Cyklus while
while (podminka) { ... }

Cyklus while se provádí tak dlouho, dokud podmínka podminka nabývá hodnoty true. Pokud podmínka nabude hodnoty false, cyklus skončí (tělo cyklu se přeskočí). U toho cyklu se může stát, že se neprovede ani jednou, neboť pomínka se vyhodnocuje před tělem cyklu.

Cyklus do-while
Cyklus do-while je podobný jako cyklus while s tím rozdílem, že podmínka se vyhodnocuje až po průchodu těla cyklu. Tedy tělo cyklu se provede pokaždé alespoň jednou.

Cyklus for
for(int i = 0; i < 10; i++) System.Console.WriteLine(i);

Cyklus foreach
Ideální k procházení všech prvků kontejneru.

using System;
using System.Collections;
...
ArrayList a = new ArrayList();
a.Add(1);
a.Add("string");
a.Add(new object);
foreach(object obj in pole)
Console.WriteLine(obj.GetType());
...

Skokové příkazy
Příkazy, které způsobí, že program přeruší přirozenou posloupnost plnění příkazů (tedy za sebou, jak jsou napsány), se nazývají skokové příkazy. Tehdy program přejde na jiné místo v programu rozdílné od této přirozené posloupnosti.

Příkaz break
Příkaz break způsobí, že program vyskočí z nejbližšího cyklu, ve kterém se právě nachází. Kromě cyklů se break smí použít i v příkazu switch.

Příkaz continue
Lze použít pouze v cyklech. Pokud použijeme tento příkaz, způsobí to, že přeskočíme zbytek těla cyklu a začneme novou iteraci (další opakování cyklu).

Příkaz goto
Tento příkaz se většinou v novějších programovacích jazycích nesetkával s oblibou. Platilo, že čím více příkazů goto, tím horší je kvalita programu. Jazyk C# tento příkaz obsahuje, ale snaží se zabránit jeho zneužití, např. nelze skočit dovnitř blokového příkazu. Tento příkaz je doporučován pro použití v příkaze switch nebo pro předání řízení do vnějšího bloku, ale ostatní použití není nepovolené.

Příkaz return
Tímto příkazem se vrací řízení volající funkci. Příkaz return může být spojen i s hodnotou, pokud metoda, která return použije, má návratovou hodnotu jinou než void. Příkazy checked a unchecked Pokud používáme konverzi typů, někdy se stane, že při konverzi z jednoho typu na druhý si chceme být jisti, že převod proběhl úspěšně. C# pro ten případ používá příkaz checked. Když potom chceme ověřit správnost konverze, uvedeme naši konverzi v kontrolovaném bloku příkazu checked.

Příkaz throw
Příkaz throw slouží k vyvolání výjimky. Uplatní se tehdy, pokud chceme ošetřit nějakou část kódu. V případě, kdy se vyskytnou jiné podmínky v programu, než jsme si představovali, můžeme pomocí throw vyvolat nějakou výjimku.