C# 2008

Základy jazyka

  1. Proměnné. Vždy obsahují datový typ a nelze jej měnit. Dovozené (var).
  2. Obor viditelnosti proměnné - členská proměnná třídy => lokální proměnná (v bloku nebo metodě) => for/while blok
  3. Konflikty viditelnosti řeší prefix. Tj. this, jméno třídy u static, namespace
  4. Konstanty - musí být známy v době překladu a jsou statické
  5. Datové typy předdefinované - celočíselné (sbyte,short,int, long, byte,ushort,uint,ulong),float, double, decimal, bool,char
  6. Referenční typy předdefinované - object, string
  7. Příkazy pro řízení běhu programu - Sekvence, Podmínky, Iterace, Jump (if else, switch case default) (do while for foreach) (return, continue greak goto)
  8. Výčtové typy (enumerátor)- uživatelskyy definovaný celočíselný typ.
  9. Pole - referenčnín typ
  10. Jmenné prostory. namespace{}. Pro logické seskupení souvisejících tříd a typů. (nikoli fyzické - to zajišťujhí soubory, komponenty). Lze je vnořovat do sebe. using. using aaa=Wrox.abcd.aaa - lze tak pomocí alias zkracovat namespace.
  11. Překlad souborů - csc /t:exe (library, module, winexe) tjh. konzole, knihovna, modul (bez manifetstu), s GUI.
  12. Dokumentace XML - strukturované komentáře umožňují tvořit dokumentaci funkcí přes tři lomítka ///. Např. <param>,<returns><summary><value> popisuje vlastnost<exception> - popis vyjímek<example>-zvýrazňuje kus kódu
  13. Direktivy preprocesoru (#define,#undef, #if,#else,#elif,#enfif, #warning,#error, #region,#endregion, #line, #pragma - +disable/restore)

Objekty a Typy

  1. Třídy a struktury jsou šablony, podle nichž se tvoří objekty (instance). Objekty obsahují data (datové členy) a metody pro manipulaci s nimi (funční členy).
  2. Struktury se liší umístěním v paměti, nelze dědit, default konstruktor inicializuje datové typy (nelze napsat vlastní prázdný konstruktor). sA = sB - dojde ke zkopírování obsahu struktury a né k zkopírování odkazu (dá se ale použít ref). Z toho plyne, že se struktury hodí pro malé množství dat. Jsou odvozeny od System.ValueType a né od System.Object.
  3. Členy třídy jsou buď instační nebo statické. Dělíme je na datové (datové složky, konstatnty a události) a funkční (metody, vlastnosti, konstruktory, finalizéry, operátory a indexery)
  4. Parametry lze předávat odkazem nebo hodnotou. I struktury lze předávat odkazem (ref, out). Přetěžování metod lze typem, počtem, pořadím, ale né návratovou hodnotou, deklarací ref/out nebo volitelnýmí parametry
  5. Properties-vlastnosti. Chovají se jako datová složka, ale mají metody get/put. Lze mít vlastnosti jen pro čtení, nebo pro zápis. Lze měnit i viditelnost.
  6. Konstruktory. Bez návratového typu + stejné jméno jako třída. Implicitní konstruktor nastaví datové složky na výchozí hodnoty. Statické konstruktory se nebijí s instančními a jsou spuštěny někdy (ale vždy před prvním použitím třídy) - vždy bez parametrů. Volání konstruktorů z jiných konstruktorů :this() a base(). This zavolá konstruktor ve své třídě a base v rodičovské třídě. Max jedno volání.
  7. Konstanty a readonly (static/instanční). Readonly lze nastavovat za běhu programu z konstruktorů. Např načtené hodnoty z konfiguračních souborů. To konstanty neumí.
  8. Anonymní typy - var doctor = new {FirstName="a", LastName = "b"}; Nebo ještě jednodušeji var osoba = new {objX.FirstName, objX.LastName}; Skutečný typ neexistuje. Překladač jim přiřadí unikátní číslo.
  9. Struktury - seskupenín datových položek, vždy public (pokud potřebuješ private zvaž třídu). Mají pevně zabudovaný konstruktor, který inicializuje datové členy.
  10. Třída vers. Struktura. Referenční/hodnotový typ, Bez dědičnosti, výchozí konstruktor (nelze přepsat), u struktur lze uspořádat datové složky v paměti. Ale pozor struktury mohou implementovat rozhraní.
  11. Partial class - Částečné třídy. Umožňuje mít jednu třídu ve více souborech. Klasicky Wizard vytvoří A a programátor B a to vše v jedné třidě, ale ve dvou souborech.
  12. private, protected, internal, public, abstract, sealed, partial
  13. Třída Object - GetType(), ToString(), GetHashCode(), Equals(Object), Equals(Object, Object), Finalize(), MemberwiseClone(),ReferenceEquals(Object, Object)
  14. Rozšiřující metody public static void ExMethod(this MyClass myClass, int par1,...){}. Když to nejde děděním.... Pozor, nelze takto přepisovat již existují metody - instační má vždy přednost.

4 Dědění

  1. Dědí se implementace (0-1x) nebo rozhraní (0-nx). Vícenásobné dědení není podporováno (tj. z více tříd najednou). Přesněji řečeno, každá třída dědí. Když není uvedeno tak z Object. (Struktury dědí z ValueType). Přesněji řečeno ze struktur nelze naprogramovat hierarchii typů.
  2. Dědit lze implementaci nebo jen abstrakce. System.Object = object.
  3. Virtuální metody VirtualOverride.cs - umožníme překrytí metody/vlastnosti nějakou z odvozených tříd. V C# nejsou metody standardně virtuální. Klíčové slove override - co znamená že metoda v odvozené třídě překrývá metodu v základní třídě.
  4. Nelze překrýt konstruktor, datové členy, vše statické. Lze překrýt pouze instanční metody a vlastnosti.
  5. Zastiňování metod (shading) VirtualOverride.cs. Lze zastínit metodu se stejnou signaturou, která ale není override. Použij new - nebo dostaneš warning. Je to ale nedoporučovaná operace.
  6. Abstraktní metody - Abstract.cs. Nelze z ní udělat instanci - funguje jako rozhraní, ale s možností mít datové členy. Abstraktní metody je třeba překrýt (override). Je implicitně virtuální.
  7. Zapečetěné třídy - pokud nechceš umožnit dědění. Důvod je utajení nebo jistota, že jakékoliv dědění je zbytečné a mohlo by naopak způsobit problémy.
  8. Konstruktory. Pokud vytvoříš konstruktor s parametry nebude implicitní konstruktor spuštěn. Private konstruktor znemožní vytvoření instance třídy. (Např. pokud tvoříš Factory a chceš třídy tvořit z metod). Statický konstruktor jen bez prametrů.
  9. Volání konstruktoru z jiných konstruktorů. Je třeba vědět že pořadí volání konstruktorů je od System.Object až po poslední zděděný. Rozlišovat this a base.
  10. Modifikátory viditelnosti
    1. public - pro libovolný kód
    2. protected - pro typ do kterého patří a všechny odvozené typy.
    3. internal - pouze pro sestavení v němž se nachází.
    4. private - pouze v typu do kterého patří
    5. protected internal dohromady oba dva (ve stylu OR)
  11. Další modifikátory
    1. new - skrývá zděděný člen se stejnou signaturou
    2. static - není instanciován - člen třídy
    3. virtual - člen může být překryt v odvozené třídě
    4. abstract - bez implementace. Jen definuje signaturu (rozhraní členu). Vždy virtual.
    5. override - Člen překrývá virtuální nebo abstraktní člen rodičovské třídy
    6. sealed - U třídy nelze odvozovat potomky. U metod/vlastností - nelze překrýt
    7. extern - pouze statické metody. DllImport. Rozhraní metody v jiném jazyku.
  12. Rozhraní - nemá konstruktor ani datové složky. Jen deklaruje. Lze deklarovat metody, vlastnosti, indexery a události. Vždy implicitně public ale není možné to definovat.
  13. Odvozená rozhraní - rozhraní mohou od sebe dědit. Hezký příklad je s rozhraním IBankAccount,, které je zděděno do ITransferBankAccount, kde v jediné metodě TransferTo() přesunuje peníze z banky do banky. Child class k tomu ale využívá metody z rodičovského rozhraní IBankAccount. BankAccount.cs

5 - Pole

  1. Za vším je skrytá třída Array. Ta nabízí metody pro třídění a filtrování polí. Pole obsahuje několik/řadu objektů stejného typu. Deklarate typ[] A1; Inicializace int[] A2 = new int[4]; Pole je refernčního typu, takže Inicializace vytvoří místo "přesné délky" na haldě.
  2. Pole tedy využijeme zpravidla pokud dopředu známe jeho délku. Pokud né použijeme radši kolekce.
  3. Různé zápisy: int[] A2 = new int[4]; int[] A2 = new int[4] {1,2,3,4}; int[] A2 = new int[] {1,2,3,4}; int[] A2 = {1,2,3,4}; Parametry indexů jen celá čísla. (Vlastní indexery mohou mít i jiné indexy).
  4. Práce s poli je přiřazení, čtení a procházení (for int i=0; i
  5. Prvky pole mohou být datové typy nebo objekty. Pro referenční typy musí být alokována paměť. Nelze pracovat s null.
  6. Více rozměrná pole A[5,2], nepravidelná pole Jagged[5][]
  7. Array - nelze z ní přímo dědit, ale syntaxí jazyka C#, vlastně vytvoříme zděděnou třídu Array. To lze obejít přes Array.CreateInstance(typeof(int),10). Pokud ale vytvořenou array rovnou nepřetypuješ (int[] A2 = (int[]) newArray), tak pak nemůžeš použít indexy a musíš přes SetValue()/GetValue(). Asi protože překladač nezná délku prvku pole.
  8. Length(), LongLength()-vrací délku v long, Rank()- vrací dimension
  9. Kopírování polí. Clone() - implementuje rozhraní ICloneable. Další možnost je statická Copy(). Ale ta už potřebuje definované pole. Vždy se vytváří mělká kopie.
  10. Třídění polí. Sort(). Pro třídění vyžaduje aby prvky pole implementovaly rozhraní IComparable. Array.Sort(person). Nebo lépe přes rozhraní IComparer, které umožní ještě definovat podle čeho třídit. Array.Sort(persons, new PersonComparer(PersonComparer.PersonCompareType.FirstName)). Sort ještě poskytuje rozhraní pro delegáty.
  11. Rozhraní - IEnumerable (pro foreach), ICollection (Count,CopyTo(),IsSynchronized=false), IList ( Clear() udělá null, Contains() true/false, IndexOf() dtto jen index prvního prvku, Item() +celočíselný index, IsFixedSize = true, IsReadOnly = false, Add()+Insert()+Remove()+RemoveAt() NotSupportedException )
  12. IEnumerator - rozhraní MoveNext(), Current, Reset().
  13. yeild return - usnadňuje vytváření Enumeratoru. V podstatě se tím dá vráti Pole (kolekce). Odporně - Metoda či vlastnost obsahující yeild se označuje jako blok iterátoru. Vrací rozhraní IEnumerable/IEnumerator. Lze použít yeild return, yeild break ale né return.
  14. Lze jednoduše ve třídě naimplementovat metody Reverse(), Subset(), které vracejí IEnumerable jednu Array různými způsoby. Samozřejmě musí existovat GetEnumerator() aby existovalo aspoň jedno rozhraní IEnumerable.
  15. yeild lze použít i složitější metodou, kdy vrací další enumerátor a ty pak máš rekurzi. Viz TicTacToe

Operátory a přetypování

    1. + - * / % - Aritmetické
    2. & ! | ~ && || - Logické
    3. + - Spojování řetězců
    4. ++ -- - Incremet, decrement
    5. << >> - bitový posun
    6. == != > < <= >= - porovnání
    7. = += -= *= /* %= &= |= ^= <<= >>= - Přiřazení (složené operátory)
    8. . - přístup k členům objektů a struktur
    9. [] - Indexovní pro pole a indexery
    10. () - přetypování
    11. ?: - ternální operátor (podmínka)
    12. + - - Spojování a odebírání delegátů
    13. new - vytváření objektů
    14. sizeof, is typeof as - informace o typu. is je kompatibilní s typem (přímo nebo přes potomka). as - explicitní převod (nejde li pak null). sizeof velikost v bytech, typeof vrací System.Type.
    15. checked, unchecked - řízení vyjímek přetečení
    16. :: - Kvalifikátor aliasu jmenného prostoru
    17. ?? - Operátor nulového sjednocení
  2. Typová bezpečnost. C#, rrsp IL vyžaduje silnou typovou bezpečnost. Implicitní převod (z long na int a zpět-to ale nejde) jen z menších na větší. Nelze null type na notnull (int? na int).
  3. Explicitní převod - autor ví co chce. Může dojít ke ztrátě dat (unchecked implicitně). MAX int = 2147483647
  4. Automatické zabalování a vybalování boxing/unboxing. Datové typy na Referenční typy a zpět. int i = 10; object o = i; int j = (int) o; Když nejde InvalidCastException. (Třeba o je long)

Delegáty a události

  1. Pokud potřebujeme předat adresu nějaké funkce do jiné třídy . Např. při volání podprocesů (thready), při třídění v generických třídách, události - informují o nějaké změně stavu, nové události
  2. Delegáty - zástupci metod. Tj adresa na funkci, ale typově zabezpečená. Delegát ale fyzicky obsahuje jen adresu.
  3. Delegát vytvoříme deklarací a zároveň naprogramuje metodu, která splňuje deklaraci. Metoda bude následně instanciována 1x i vícekrát. (delegate int IntMethodInvoker(int x);). Každý delegat je vlastně třída odvozená od System.MultiCastDelegate.
  4. private delegate string GetAString(); odkaz na metodu co vrací string a nepřijímá žádný parameter. int x = 40; GetAString StringMethod = new GetAString(x.GetHashCode().ToString); jako metodu použijeme ToString - instanční metoda z int.
  5. Volání se dá zkrátit tzv. inference - dovození GetAString StringMethod = x.GetHashCode().ToString;. Syntactics sugar, protože překladač přeci ví, že StringMethod je delegát. V každém případě překladač vytvoří novou instanci.
  6. Vícenásobné delegáty - += -= delegáty lze zřetězovat. Např při obClick metodě lze udělat více akcí najednou. Pořadí volání není zaručeno. Další problém jsou vyjímky. Stačí aby u prvního systém vyvolal vyjímku a neprojde žádný další. Třída Delegate má metodu GetInvocationList a tak můžeš procházet seznam volání podle sebe. Je pak zaručeno pořadí i lzeošetřit vyjímky.
  7. Anonymní metody. Je v podstatě delegát jehož tělo vytvoříš v kódu a použiješ. Je to proměnná na úrovni třídy. Platí omezení - žádný out/ref, žádné skoky ven a ani dovnitř. Vhodné pro jednorázové použití. Pro vícenásobné použij pojmenovanou
  8. Lambda výrazy. Je to jen syntaxe Anonymních metod. delegate (param) nahradíš param =>. nebo (param1,param2 =>) . Typ není nutné zadávat překladač si ho zjistí.
  9. Kovariance, kontavariance. Metoda, kterou delegát volá nemusí být schodný s deklarací. Lze volat i rodičovské třídy.
  10. Události. Události z pohledu příjemce buttonOne.Click += new EventHandler(Button_Click). Vyvolání události EventArgs

Řetězce a regulární výrazy

Genericita

  1. Genericita je definována v CLR. Podobně fungují v c++ šablony, ale potřebuješ zdroják. Zejména pro třídy kolekcí. Lze to udělat přes Object, ale musíš přetypovávat.
  2. Výkon - nedochází k boxingu. Třída ArrayList umožňuje heterogenní třídy a je to vlastně List<Object>. Lepší je samozřejmě List<T>

Kolekce

LINQ

Správa paměti a ukazatele

Reflexe

Chyby a vyjímky

Návrhové vzory

SOLID

GOF gang Of Four (itnetwork - karia/mat)

Creational patterns (pro vytváření)

Structural patterns (struktury)

Vzory chování

Příklady