C Sharp 4.0 - C Sharp 4.0

Správný název tohoto článku je C # 4.0. Nahrazení # je to kvůli technická omezení.

C # 4.0 je verze C# programovací jazyk, který byl vydán 11. dubna 2010. Microsoft vydala 4.0 runtime a vývojové prostředí Visual Studio 2010.[1] Hlavním zaměřením C # 4.0 je interoperabilita s částečně nebo plně dynamicky napsanými jazyky a rozhraními, jako je Dynamic Language Runtime a KOM.

Funkce

V C # 4.0 byly přidány následující nové funkce.[2]

Dynamické vyhledávání členů

Nový pseudotyp dynamický je zaveden do systému typu C #. Je to považováno za System.Object, ale navíc je povolen jakýkoli přístup člena (volání metody, pole, vlastnost nebo přístup indexeru nebo volání delegáta) nebo aplikace operátoru na hodnotě takového typu bez jakékoli kontroly typu a jeho řešení je odloženo do spuštění -čas. Toto je známé jako kachní psaní. Například:

  // Vrátí hodnotu vlastnosti Délka nebo pole libovolného objektu  int GetLength(dynamický obj)  {    vrátit se obj.Délka;  }    GetLength("Ahoj světe");        // řetězec má vlastnost Délka,  GetLength(Nový int[] { 1, 2, 3 }); // a také pole,  GetLength(42);                    // ale ne celé číslo - v metodě GetLength bude za běhu vyvolána výjimka

Volání dynamických metod jsou spouštěna hodnotou typu dynamický jako jakýkoli implicitní nebo explicitní parametr (a nejen přijímač). Například:

  prázdnota Tisk(dynamický obj)  {     Systém.Řídicí panel.WriteLine(obj); // o kterém přetížení WriteLine () se má rozhodnout za běhu  }  Tisk(123);   // skončí volání WriteLine (int)  Tisk(„abc“); // končí volání WriteLine (řetězec)

Dynamické vyhledávání se provádí pomocí tří odlišných mechanismů: COM IDispatch pro objekty COM, IDynamicMetaObjectProvider DLR rozhraní pro objekty implementující toto rozhraní a odraz pro všechny ostatní objekty. Libovolná třída C # proto může zachytit dynamická volání svých instancí implementací IDynamicMetaObjectProvider.

V případě volání dynamické metody a indexeru se rozlišení přetížení děje za běhu podle skutečných typů hodnot předaných jako argumenty, ale jinak podle obvyklých pravidel rozlišení přetížení C #. Kromě toho v případech, kdy přijímač v dynamickém volání není sám dynamický, rozlišení přetížení za běhu bude brát v úvahu pouze metody, které jsou vystaveny na deklarovaném typu kompilace přijímače. Například:

třída Základna{  prázdnota Foo(dvojnásobek X);}třída Odvozený : Základna{  prázdnota Foo(int X);}dynamický X = 123;Základna b = Nový Odvozený();b.Foo(X); // vybere Base.Foo (double), protože b je typu Base a Derived.Foo (int) není vystavendynamický b1 = b;b1.Foo(X); // vybere Derived.Foo (int)

Jakákoli hodnota vrácená z přístupu dynamického člena je sama o sobě typu dynamický. Hodnoty typu dynamický jsou implicitně konvertibilní jak za na jakýkoli jiný typ. V ukázce kódu výše to umožňuje GetLength funkce k léčbě hodnoty vrácené voláním Délka jako celé číslo bez explicitního obsazení. Za běhu bude skutečná hodnota převedena na požadovaný typ.

Covariantní a kontravariantní parametry obecného typu

Obecný rozhraní a delegáti mohou mít své parametry typu označené jako kovariantní nebo kontravariantní pomocí klíčových slov ven a v resp. Tyto deklarace jsou pak respektovány pro převody typů, implicitní i explicitní, a to jak čas kompilace, tak čas běhu. Například stávající rozhraní IEnumerable byl předefinován takto:

rozhraní IEnumerable<ven T>{  IEnumerator<T> GetEnumerator();}

Proto každá třída, která implementuje IEnumerable pro nějakou třídu Odvozený je také považován za kompatibilní s IEnumerable pro všechny třídy a rozhraní Základna že Odvozený rozšiřuje, přímo nebo nepřímo. V praxi to umožňuje psát kód jako:

prázdnota Tisknout vše(IEnumerable<objekt> předměty){  pro každého (objekt Ó v předměty)  {    Systém.Řídicí panel.WriteLine(Ó);  }}IEnumerable<tětiva> struny = Nový Seznam<tětiva>();Tisknout vše(struny); // IEnumerable  je implicitně převeden na IEnumerable 
Pro kontrarariance stávající rozhraní IComparer  byl předefinován takto:
veřejnost rozhraní IComparer<v T>{    int Porovnat(T X, T y);}
Proto každá třída, která implementuje IComparer  pro nějakou třídu Základna je také považován za kompatibilní s IComparer  pro všechny třídy a rozhraní Odvozený které jsou rozšířeny z Základna. Umožňuje psát kód, jako například:
IComparer<objekt> porovnávač objektů = GetComparer();IComparer<tětiva> stringComparer = porovnávač objektů;
Volitelné klíčové slovo ref při použití modelu COM
The ref klíčové slovo pro volající metody je nyní volitelné při volání do metod poskytovaných KOM rozhraní. Vzhledem k metodě COM s podpisem
prázdnota Přírůstek(ref int X);
vyvolání lze nyní zapsat buď jako
Přírůstek(0); // již není potřeba „ref“ nebo proměnná placeholder
nebo
int X = 0;Přírůstek(ref X);
Nepovinné parametry a pojmenované argumenty
C # 4.0 zavádí volitelné parametry s výchozími hodnotami, jak je vidět na Visual Basic a C ++. Například:
prázdnota Přírůstek(ref int X, int dx = 1){  X += dx;}int X = 0;Přírůstek(ref X);    // dx přebírá výchozí hodnotu 1 poté, co metoda vrátí x == 1Přírůstek(ref X, 2); // dx nabývá hodnoty 2 poté, co metoda vrátí x == 3
Kromě toho k doplnění volitelných parametrů je možné explicitně zadat názvy parametrů ve volání metod, což programátoru umožňuje selektivně předat libovolnou podmnožinu volitelných parametrů pro metodu. Jediným omezením je to pojmenované parametry musí být umístěny za nepojmenovanými parametry. Názvy parametrů lze zadat pro volitelné i povinné parametry a lze je použít ke zlepšení čitelnosti nebo k libovolnému přeuspořádání argumentů ve volání. Například:
Proud Otevřít soubor(tětiva název, Režim souboru režimu = Režim souboru.Otevřeno, FileAccess přístup = FileAccess.Číst) { ... }Otevřít soubor("file.txt"); // použít výchozí hodnoty pro „režim“ i „přístup“ Otevřít soubor("file.txt", režimu: Režim souboru.Vytvořit); // použít výchozí hodnotu pro „přístup“Otevřít soubor("file.txt", přístup: FileAccess.Číst); // použít výchozí hodnotu pro „režim“Otevřít soubor(název: "file.txt", přístup: FileAccess.Číst, režimu: Režim souboru.Vytvořit); // pojmenujte všechny parametry pro lepší čitelnost,                                                                             // a použít pořadí odlišné od deklarace metody
Volitelné parametry usnadňují spolupráci s COM. Dříve musel C # předat každý parametr v metodě komponenty COM, dokonce i ty, které jsou volitelné. Například:
objekt název souboru = „Test.docx“;objekt chybějící = Systém.Odraz.Chybějící.Hodnota;doc.Uložit jako(ref název souboru,    ref chybějící, ref chybějící, ref chybějící,    ref chybějící, ref chybějící, ref chybějící,    ref chybějící, ref chybějící, ref chybějící,    ref chybějící, ref chybějící, ref chybějící,    ref chybějící, ref chybějící, ref chybějící);
S podporou volitelných parametrů lze kód zkrátit jako
doc.Uložit jako(ref název souboru);
Což díky nyní volitelnému ref klíčové slovo při použití modelu COM lze dále zkrátit na
doc.Uložit jako(název souboru);
Indexované vlastnosti
Indexované vlastnosti (a výchozí vlastnosti) objektů COM jsou nyní rozpoznány, ale objekty C # je stále nepodporují.
Reference
  1. ^ „První pohled na Microsoft Visual Studio 2010“.
  2. ^ Torgersen, Mads (2008-10-27). „Nové funkce v C # 4.0“. Microsoft. Citováno 2008-10-28.
externí odkazy