1. Konstruktory a inicializátory:
a) Z konstruktorů je možné volat virtuální metody, fungují normálně.
b) Kdykoliv je konstruována nová instance třídy, nejprve se incializují všech členské proměnné, poté se zavolají konstruktory v pořadí od System.Object až po samotnou třídu.
c) Statické inicializátory mohou být spuštěny kdykoliv, ovšem určitě nejpozději před referencováním dané třídy. Pokud ovšem třída má i statický konstruktor, budou spuštěny těsně před ním.
d) Statický konstruktor, existuje-li, je spuštěn právě těsně před tím, než se zdrojový kód odkazuje na nějakou jeho statickou položku nebo těsně před tím, než se zkonstruuje instance dané třídy, co přijde dřív.
e) Inicializátory členských proměnných se nesmí odkazovat na "this" nebo ostatní členské proměnné. Mohou se tedy odkazovat jen na statické věci.
f) Inicializátory proměnných se spouští v pořadí, v jakém jsou pod sebou ve zdrojovém kódu. Pro "partial" typy je pořadí nedefinováno.
g) Pokud ve **třídě** nadefinujete libovolný konstruktor, bezparametrický konstruktor se automaticky nevygeneruje.
h) Ve **struktuře** nelze nadefinovat bezparametrický konstuktor a ten výchozí se vygeneruje vždycky.
i) (EXPERT) Inicializátor kolekce "List<int> v = new List<int> { 2, 3 }" lze použít na typech, které implementují rozhraní IEnumerable a navíc pro každou věc v inicializátoru mají příslušnou metodu Add.
2. Výchozí hodnoty
a) Výchozí hodnota všech static proměnných je 0, false, null nebo, pokud je to struktura, to samé rekurzivně na její členy a statické položky.
b) Výchozí hodnota všech členských proměnných třídy nebo struktury je 0, false, null nebo, pokud je to struktura, to samé rekurzivně na její členy a statické položky.
d) Lokální proměnné nemají žádnou výchozí hodnoty. Je compile error se pokusit číst potenciálně nepřiřazenou lokální proměnnou. Kompilátor řeší toto tak, že se zeptá "Je naprosto jisté, již za kompilace, že bude hodnota vždy přiřazena, a to i tehdy, když mi někdo bude šahat pod ruku a měnit mi hodnoty proměnných, jak se mu zachce (třeba z jiného vlákna)?" + hromada technických detailů
3. Struktury
a) Struktury jsou hodnotové typy. Operátor přiřazení provádí mělkou kopii, nikoliv přiřazení reference.
b) Struktury neumí dědit, ale mohou implementovat interfacy (např. IComparable). Všech struktury implicitně dědí od System.ValueType. Číselné typy lze zjednodušeně považovat za struktury.
c) Struktura nesmí mít destruktor.
d) Struktura nesmí mít vlastní uživatelem definovaný bezparametrický konstruktor.
e) Struktura nesmí mit u svých členských proměnných inicializátory. (Ale může mít u svých statických položek inicializátory.)
f) Struktury na sobě nesmí záviset: struct A { B b; } struct B { A a; } je compile error.
g) Pokud máte List<someStruct> struktur, pak list[0] vrací kopii struktury jako r-hodnotu, je compile error napsat list[0].x = 1; (toto platí jen pro List struktur a podobně, nikoliv pro pole struktur)
h) Struktury nesmí mít virtuální ani abstraktní metody. Mohou mít statické metody.
i) Třídy nesmí dědit od struktur.
j) Struktury (včetně základních číselných typů) se mohou vyskytnout na haldě, pokud jsou to členské proměnné nějakého referenčního typu, nebo ve statickém prostoru, pokud existuje jejich statická instance. Nemusí se tedy nutně vyskytovat pouze na zásobníku.
k) Narozdíl od C++, výchozí viditelnost členů struktury je "private".
4. Base Class Library
a) String nemá žádnou metodu, která by ho dokázala modifikovat ("je immutable"). Jeho metody typu ".Replace()" změněný řetězec jen vrací.
b) Jednoduché immutable datové kontejnery (kromě stringu) jsou obecně implementované jako struktury, vše ostatní jako třídy. Tedy System.Drawing.Point, System.DateTime, System.TimeSpan jsou struktury.
c) String je vnitřně reprezentován pole znaků. Znaky v C#, a stringy v .NET, používají UTF-16 kódování a každý znak má 2 bajty.
5. Velikosti typů
a) byte = 1B, short = 2B, int, float = 4B, long, double = 8B, char = 2B
b) string = nedefinováno (záleží na implementaci)
c) struktury, třídy = nedefinováno (záleží na implementaci)
d) Pole jsou referenční typy, jejich velikost je nedefinovaná
6. Úplný výčet hodnotových typů
Existují právě tyto hodnotové typy:
a) Enumerace
b) Struktury
c) Čísla: sbyte, byte, short, ushort, int, uint, long, ulong, float, double, decimal (a jejich plné názvy)
d) bool (System.Boolean)
e) Nulovatelné typy: System.Nullable<T> nebo T?, kde T je jiný hodnotový typ
7. Interfacy
a) Každá struktura či třída může implementovat libovolný počet interfaců. Nemusí implementovat žádný.
b) Interfacy od sebe můžou navzájem dědit. Jeden interface může dědit od více interfaců. Neexistuje žádný společný prapředek všech interfaců.
c) Interface může vynutit výlučně:
c1) Existenci public metody (normální nebo explicitně implementované) s daným jménem, návratovým typem a parametry.
c2) Existenci public property (buď public get, nebo public set, nebo obojí)
c3) Existenci eventu
c4) Existenci indexeru s danými parametry
c5) Nic jiného vynutit lze, speciálně tedy nelze vynutit operátory nebo proměnné (to je rozdíl oproti Javě), ani žádný modifikátor u metody (např. private, static, virtual nebo abstract)
d) Třída nebo struktura může jednotlivé metody, property, eventy a indexery jednotlivých rozhraní implementovat buď standartně nebo explicitně. Nemůže mít dvě metody se stejnou signaturou implementovány standartně, ale compile erroru se dá vyhnout, pokud alespoň jedna z nich (klidně obě) budou implementovány explicitně. Rozhraní "interface I { void m(); }" se explicitně implementuje takto: "class C : I { void I.m() { } }".
e) Je možné implementovat generické rozhraní vícekrát, pokaždé ovšem s aspoň jedním jiným typovým parametrem.
f) Pokud třída implementuje nějaký interface, pak musí nabízet všechny jeho metody, vlastnosti, eventy a indexery jako public non-abstract non-static, ale mohou být virtuální, jinak máme compile error. Není nutně byť metodu implementovat normálně, stačí vše implementovat explicitně.
g) Explicitní implementaci metody "method" interfacu "I" provedete takto (všimněte si, že tam není žádný modifikátor viditelnosti): "void I.method() { /*kod*/ }"
h) Následující kód je legální, přestože "A a = new A(); a.m()" nepůjde přeložit: "interface I { void m(); } class A : I { void I.m() { } }".
8. Generika
a) Pomocí "where" požadavků není možné vynutit existenci operátory. Lze vynutit: class (referenční typ), struct (hodnotový typ), new() (existence bezparametrického konstruktoru), INeco (implementace interfacu INeco), TNeco (odvozenost od třídy TNeco)
b) Pokud generická třída dědí od generické třídy podle stejného typového parametru, tento je určen během vytvoření odvozené třídy. Tedy, pokud mám "class A<T> : B<T>, I<T>", a zavolám "A<int> a = new A<int>();", pak "a" je typu A<int>, který dědí od B<int> a implementuje I<int>.
9. Operátory
a) Operátory můžete předefinovat v libovolné třídy, která je jedním z parametrů operátoru.
b) Nelze předefinovat operátory =,+=,-=,*= a podobně, ty fungují automaticky.
c) U binárních operací "|" je OR, "^" je XOR, "&" je AND, "~" je NOT. NOT nelze použít na typ boolean, místo toho je třeba použít "!".
d) && a || používají zkrácené vyhodnocování a nedají se předefinovat.
e) Priorita operátorů je:
e1) a++
e2) ++a, unární mínus, ~ (NOT)
e3) *,/
e4) +,-
e5) & (AND)
e6) ^ (XOR)
e7) | (OR)
f) Operátor "is" znamená "Je výraz vlevo potomkem třídy vpravo; nebo, pokud je vpravo rozhraní, implementuje výraz vlevo toto rozhraní?"
g) Operátor "typeof()" bere třídu nebo interface (nikoliv instanci třídy) a vrací instanci typu Type, který reprezentuje tuto třídu nebo interface.
h) Funkce .GetType() je implementována na System.Object a vrací instance typu Type, který odpoví instanci, nevrací tedy type System.Objectu. Řádka "instance.GetType() == typeof(SomeClass)" tedy porovnává přímo typ "instance" s "SomeClass", nestačí, že instance od SomeClass dědí.
i) Operátor "as" je syntaktická zkratka (plus mínus) za "(instance is SomeClass ? (SomeClass)instance : null)".
j) Operátor bitového posunu vlevo << vyplňuje zprava nulami.
k) Operátor bitového posunu vpravo >> vyplňuje zlevo nulami, pokud číslo bylo kladné, a jedničkami, pokud bylo číslo záporné.
m) Operátor == je často předefinovaný. Konkrétně u stringů operátor == porovnává znak po znaku. To je rozdíl oproti Javě.
n) Operátory nejsou nikdy virtuální. Tedy pokud typ přetypujete na Object, bude se používat == na objektu, tedy porovnávání referencí.
10. Pole
a) Pole jsou kovariantní pro referenční typy pouze. I tak, pokud uděláte "object[] o = new string[] { "A" }", projde to, ale pokud později uděláte "o[0] = 2;", vyhodí to ArrayTypeMismatchException.
b) Pole jsou referenční typy.
c) Pole se dají inicializovat přímo takto "int[] a = { 2, 3, 4 }", ovšem tento zkrácený zápis je možné použít jen při deklaraci. Tedy "a = {2,3,4}" už je compile error.
11. Polymorfismus
a) Neexistuje vícenásobná dědičnost, třída nebo struktura ale může implementovat více interfaců.
b) Všechny třídy a struktury (včetně zabudovaných číselných typů) mají System.Object jako prapředka. Všechny hodnotové typy mají System.ValueType jako předka, System.ValueType je sám referenční typ.
c) Nelze odvozovat od tříd označených jako "sealed".
12. Výchozí viditelnost
a) Základní pravidlo je, že každá věc má nejmenší možnou výchozí viditelnost.
b) Výchozí viditelnost členských i statických položek a metod tříd a struktur je "private" (to je rozdíl oproti C++ a Javě)
d) Výchozí viditelnost vnořených typů je "private".
e) Výchozí viditelnost vnějších typů je "internal".
13. Platform target, AnyCPU, x86, x64
a) Při kompilaci DLL knihovny nebo EXE souboru zvolíte, zda se jedná o "AnyCPU", "x86" nebo "x64" assembly. Tímto se jen nastaví příznak v hlavičce assembly, IL kód se vygeneruje stejný.
b) Na 32-bitovém systému:
b1) x86 EXE soubory se spustí normálně, v 32-bitovém režimu.
b2) AnyCPU EXE soubory se spustí normálně, v 32-bitovém režimu.
b3) x64 EXE soubory se odmítnou spustit. ("Verze souboru není kompatibilní se spuštěnou verzí systému Windows")
c) Na 64-bitovém systému:
c1) x86 EXE soubory se spustí v emulovaném 32-bitovém režimu ("WOW64" na Windows).
c2) AnyCPU EXE soubory se spustít v 64-bitovém režimu.
c3) x64 EXE soubory se spustí v 64-bitovém režimu.
d) Co se týče DLL knihoven,
d1) x86 DLL knihovna se načte do programu, který běží v 32-bitovém režimu, normálně.
d2) x86 DLL knihovna se odmítne načíst do programu, který běží v 64-bitovém režimu. (BadImageFormatException)
d3) x64 DLL knihovna se načte do programu, který běží v 64-bitovém režimu, normálně.
d4) x64 DLL knihovna se odmítne načíst do programu, který běží v 32-bitovém režimu. (BadImageFormatException)
d5) AnyCPU DLL knihovna se načte do programu, který beží v 32-bitovém režimue, 32-bitově.
d6) AnyCPU DLL knihovna se načte do programu, který beží v 64-bitovém režimue, 64-bitově.
d7) Příklad: "a.exe" je AnyCPU, "b.dll" je x86. Program "a.exe" načítá knihovnu "b.dll". Pokud spustíme program "a.exe" na 64-bitových Windows, tak a.exe se spustí 64-bitově a pokusí se načíst 32-bitovou knihovnu b.dll. Jakmile se o to pokusí (např. chce zkontstruovat nějakou třídu z ní), tak vypadne BadImageFormatException.
14. Extension metody
a) Extension metody jsou statické metody uvnitř statických tříd, které obsahují právě jeden "this" parametr, a to na prvním místě, jehož typ se musí shodovat s typem struktury nebo třídy, kterou rozšiřujete, existence implicitní konverze nestačí. Stačí ovšem "implicitní referenční konverze", která existuje např. z odvozené třídy do její base class.
15. Volatile a paměťové bariéry
a) Čtení z volatile proměnné proběhne určitě před čímkoliv, co je textově pod ním. (mnemotechnika: "čtení otevírá/zpřístupňuje další text")
b) Zápis do volatile proměnné proběhne určitě po čemkoliv, co je textově nad ním. (mnemotechnika: "zápis uzavírá práci s předchozím textem")
c) Není doporučeno se spoléhat na volatile, pokud nevíte přesně, co děláte. Použití "lock" je téměř vždy výhodnější.
16. Přetypování
a) Implicitně lze přetypovat cokoliv, co má "implicit" konvertovací operátor.
b) Implicitně lze přetypovat cokoliv na svého předka.
c) Implicitně lze přetypovat číselný typ na větší číselný typ.
d) Explicitně lze přetypovat cokoliv, co má "explicit" konvertovací operátor.
e) Explicitně lze přetypovat cokoliv na svého potomka (nebo se vyhodí výjimka).
f) Explicitně lze přetypovat číselný typ na menší číselný typ (přebytečné bajty se zahodí).
g) (ADVANCED) Není možné definovat jak implicitní, tak explicitní konverze. To vyústí v compile error.
h) (ADVANCED) Pokud explicitně převádíte něco, co lze přetypovat implicitně, bude to normálně fungovat a nevyhodí se ani warning.
17. Kovariance a kontravariance pro interfacy
a) Kovariantní typové parametry se označují slovem "out"
b) Kontravariantní typové parametry se označují slovy "in"
c) Kovariance a kontravariance funguje jen pro referenční typy.
d) Abyste mohli parametr deklarovat jako kovariantní "out", nesmíte ho použít v parametrech metod.
e) Abyste mohli parametr deklarovat jako kontravariantní "in", nesmíte ho použít v návratových hodnotách metod.
f) Protože IEnumerable<out T> je kovariantní podle T, je možné napsat "IEnumerable<object> o = new List<String>()"
18. Iterátorové funkce
a) Pokud funkce obsahuje byť jedno klíčové slovo "yield break;" nebo "yield return", je to iterátorová funkce a nesmí obsahovat samostatně klíčové slovo "return" a její návratový typ musí být "IEnumerable<T>" nebo "IEnumerable" nebo "IEnumerator<T>" nebo "IEnumerator"
b) Z této vygeneruje anonymní třída implementují GetEnumerator(), která vrací anonymní enumerátor s metodou "MoveNext" a readonly vlastností "Current". Do těchto dvou se nějakým způsobem překopíruje kód původní metody. Tam, kde je v kódu volání původní metody, se jen vytvoří instance této anonymní třídy a ta vrátí. Až během samotného použití IEnumerable se zavolá poprvé metoda MoveNext() a vykoná se první část kódu původní metody.
19. Uzavírání přes lambda funkce
a) ???
20. (ADVANCED) Lokalizace a globalizace
a) Nastavení Thread.CurrentCulture určuje, jak se chovat k datům, číslům a porovnávání řetězců.
b) Nastavení Thread.CurrentUICulture určuje, jaký .resx soubor (který obsahuje texty pro uživatelské rozhraní) se použije.
c) Defaultně jsou tato nastavena podle nastavení operačního systému. Na Windows, CurrentUICulture se nastavuje podle jazykové mutace Windows, CurrentCulture se nastavuje podle "místních a jazykových nastavení".
d) InvariantCulture není to samé, co new CultureInfo("en-US"), konkrétně uvádí + před kladná čísla, má jiný symbol pro měnu, jiný výchozí formát data a času, a používá metrický systém.
e) String.Equals využívá porovnávač String.CompareOrdinal, zatímco String.CompareTo využívá Thread.CurrentCulture.
f) StringInfo umožňuje procházet řetězec po grafémech. CompareInfo umožňuje porovnávat bez ohledu na diakritiku.
21. (ADVANCED) Vlákna
a) Instance .NET třídy Thread nemusí nutně odpovídat vláknu operačního systému, ale všechny implementace to tak dělají.
b) Thread.Yield() vynutí přeplánování procesoru na jiné vlákno, pokud nějaké ready-to-run vlákno existuje. To je rozdíl oproti Javě, kde je Thread.yield() jen doporučení.
22. Přetěžování metod
a) Pokud je na výběr možností, kterou metodu zavolat, vybere se ta, která je lepší než všechny ostatní. Pokud je jich více stejně dobrých, je to compile error.
b) Při hledání metod se nejprve hledají metody přímo textově zapsané v dané třídě, a to pouze ty, které jsou přístupné (accessible), mají stejný počet a typ parametrů jako volání, popř. existují implicitní konverze mezi typy (applicable) a nemají klíčové slovo override
b2) Pokud tento postup žádnou metodu nenajde, jde se o třídu výš, kde se hledání metod opakuje. Jakmile se nějaké metody v nějaké třídě najdou, už se o hornější třídy nezajímáme. Pokud ani v System.Object danou metodu nenajdeme, je to compile error.
c) Jakmile máme sadu metod, je třeba z nich vybrat tu nejlepší. To je ta, která je lepší než všechny ostatní.
????
?. Ostatní
a) Na statické členy není možné se odkazovat přes instanci. Pokud A je třída, a je instance třídy A, m je statická metoda A, pak je možné volat A.m() ae je compile error se pokusit o a.m(). Toto je rozdíl oproti Javě.
b) short, int a long jsou znaménkové typy. byte je bezznaménkový typ.
c) Pomocí "lock (o) {}" se dá zamykat pouze nad instancí referenčního typu, tj. "o" musí být non-null instance referenčního typu.
d) Klíčové slovo "var" je jen syntaktická zkratka. Těsně před kompilací kompilátor nahradí slovo var příslušným typem podle toho, co je na pravé straně. Tedy "var x = "Hello"" je to samé jako "string x = "Hello"".
e) Destruktury zavolá runtime nejdříve poté, co je možné dané instance zgarbagecollectovat, ale udělá to teprve, jakmile uzná za vhodná, a to v nedefinovaném pořadí. Destruktory se volají v opačném pořadí (nejprve nejvíce specifická třída, a až nakonec destruktor System.Objectu). Když se program ukončí, destruktory se spustí také. Volání "GC.Collect()" vynutí spuštění destruktorů na všech zgarbagecollectovatelných objektech, ovšem opět v nedefinovaném pořadí.
f) Indexery se překládají do CIL kódu jako pseudovlastnosti se jménem Item. Nelze nadeklarovat property Item a zároveň indexer. Je ovšem možné naimplementovat více indexerů, pokud mají různé signatury.
g) Třídy nikdy nemohou být na zásobníku, a vždycky se nacházejí na haldě.
h) Existence zásobníku a haldy jsou implementační detaily. Specifikace C# nevyžaduje, aby zásobník vůbec existoval, ale jak Microsoftí implementace, tak Mono ho používají.
i) Kontrola na přetečení se při aritmetice neprovádí, pokud neuzavřete výraz nebo příkaz do "checked" bloku.
j) Stejně jako v Javě, aritmetika se provádí alespoň a intech. Shorty a byty jsou před výpočtem převedeny na inty. Příkaz "short a = 2; short b = 4; short c = a + b;" vyhodí compile error "Cannot convert int to short".
k) String.Equals porovnává řetězce s využitím Thread.CurrentThread.CurrentCulture. To má efekt například, když se porovnávají vícebajtové Unicode znaky.
m) "int" je jen syntaktický alias za System.Int32. Obdobně "long"="System.Int64",short="System.Int16",float"="System.Single","bool"="System.Boolean","object"="System.Object" a podobně.
n) Výjimku "System.StackOverflowException", která vznikne při nekonečné rekurzi, nelze odchytit a program při ní bezpodmínečně spadne. Výjimku "System.OutOfMemoryException", která vznikne při zaplnění paměti, odchytit typicky lze.
p) Příkaz "using" bere do kulatých závorek něco, co implementuje IDisposable, a na svém konci zavolá na tomto objektu ".Dispose()".
q) Všechny volání funkcí se do CIL kódu překládají jako "callvirt". Až za běhu se roozhodne, zda se zavolají virtuálně, nebo ne. Jedinou výjimkou jsou volání "base.neco()" a volání konstruktoru předka, která jsou vždy nevirtuální.
!. Další témata:
a) Typová inference
b) Method overloading
c) Kovariance a kontravariance podrobněji
d) Uzavírání přes lambda funkce
e) Vyhodnocování aritmetiky