Specifikace CTS (Common Type System)

Specifikace CTS (Common Type System) definuje, jak jsou typy deklarovány, používány a spravovány v modulu CLR (Common Language Runtime). Rovněž tvoří důležitou součást podpory mezi jazykové integrace v modulu runtime. Specifikace CTS (Common Type System) plní následující funkce:

• Vytváří rámec, který pomáhá umožnit mezi jazykovou integraci, typovou bezpečnost a vysoký výkon provádění kódu.

• Poskytuje objektově orientovaný model, který podporuje úplnou implementaci mnoha programovacích jazyků.

• Definuje pravidla, která musí jazyky splňovat. Tato pravidla pomáhají zajistit umožnění vzájemné komunikace objektů, které jsou napsány v různých jazycích.

• Poskytuje knihovnu obsahující primitivní datové typy (například Boolean, Byte, Char, Int32 a UInt64) používané při vývoji aplikace.

Toto téma obsahuje následující oddíly:

• Typy v rozhraní .NET Framework

• Definice typů

• Členy typu

• Charakteristiky členů typu

Typy v rozhraní .NET Framework

Všechny typy v rozhraní .NET Framework jsou buď hodnotové nebo odkazové .

Hodnotové typy jsou datové typy, jejichž objekty jsou reprezentovány skutečnou hodnotou daného objektu. Pokud je instance hodnotového typu přiřazena proměnné, je této proměnné předána nová kopie hodnoty.

Odkazové typy jsou datové typy, jejichž objekty jsou reprezentovány (podobně jako ukazatel) odkazem na skutečnou hodnotu objektu. Pokud je odkazový typ přiřazen k proměnné, tak tato proměnná odkazuje (směřuje) na původní hodnotu. Není vytvořena žádná kopie.

Specifikace CTS (Common Type System) v rozhraní .NET Framework podporuje následujících pět kategorií typů:

• Třídy

• Struktury

• Výčty

• Rozhraní

• Delegáti

Třídy

Třída je odkazový typ. Může být odvozena přímo z jiné třídy a je implicitně odvozena z třídy System.Object. Třída definuje operace, které může objekt (ten, který je instancí dané třídy) provádět (metody, události nebo vlastnosti) a data, která objekt obsahuje (položky). Přestože třída obecně zahrnuje definici i implementaci (na rozdíl od rozhraní, která obsahují pouze definici bez implementace), tak může mít jednoho nebo více členů, kteří implementaci nemají.

Následující tabulka popisuje některé vlastnosti, které třída může mít. Každý jazyk, který podporuje modul runtime poskytuje způsob, jak vyjádřit, že třída nebo člen třídy má jednu nebo více těchto vlastností. Nicméně jednotlivé programovací jazyky, které se zaměřují na rozhraní .NET Framework nemusí mít všechny tyto vlastnosti přístupné.

Vlastnost	Popis
sealed	Specifikuje, že jiná třída nemůže být odvozena z tohoto typu.
implements	Označuje, že třída používá jedno nebo více rozhraní, jelikož implementuje členy daného rozhraní.
abstract	Označuje, že nelze vytvořit instanci dané třídy. Chcete-li ji použít, je nutné z této třídy odvodit další.
inherits	Označuje, že instance této třídy mohou být použity kdekoli je specifikována základní třída. Odvozená třída, která dědí ze základní třídy, můžete použít implementaci libovolného veřejného člena, kterou poskytuje základní třída nebo může přepsat implementaci veřejného člena vlastní implementací.
exported or not exported	Označuje, zda je třída viditelná vně sestavení, ve kterém je definována. Tato vlastnost se týká pouze tříd na nejvyšší úrovni, nikoliv vnořených tříd.

Poznámka
Třída také může být vnořena v rodičovské třídě nebo struktuře.Vnořené třídy také mají členské charakteristiky.Další informace naleznete v tématu Nested Types.

Členy třídy, které nemají implementaci se nazývají abstraktní členy. Třída, která má jeden nebo více abstraktních členů je sama o sobě abstraktní; nelze z ní vytvořit nové instance. Některé jazyky, které se zaměřují na modul runtime, vám umožňují označit třídu jako abstraktní i v případě, kdy žádný z jejích členů není abstraktní. Můžete použít abstraktní třídu, pokud chcete zapouzdřit základní sadu funkcí, kterou odvozené třídy mohou dědit nebo v případě potřeby přepsat. Třídy, které nejsou abstraktní jsou označovány jako konkrétní třídy.

Třída může implementovat libovolný počet rozhraní, ale může dědit pouze z jediné základní třídy. Navíc všechny třídy implicitně dědí z třídy System.Object. Všechny třídy musí mít alespoň jeden konstruktor, který inicializuje nové instance třídy. Pokud konstruktor explicitně nedefinujete, většina kompilátorů automaticky poskytne výchozí konstruktor (bez parametrů).

Struktury

Struktura je hodnotový typ, který se implicitně odvozuje z System.ValueType, ten je zase odvozen z System.Object. Struktura je velmi užitečná pro reprezentování hodnot, které mají malé požadavky na paměť a pro předávání parametrů hodnotou metodám, které mají typově silné parametry. V knihovně tříd rozhraní .NET Framework, jsou všechny primitivní datové typy (Boolean, Byte, Char, DateTime, Decimal, Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32 a UInt64) definovány jako struktury.

Stejně jako třídy, struktury definují data (položky struktury) i operace, které mohou být provedeny na těchto datech (metody struktury). To znamená, že můžete volat metody ve strukturách včetně virtuálních metod definovaných v třídách System.Object a System.ValueType, stejně tak jakékoli metody definované na samotném hodnotovém typu. Jinak řečeno struktury mohou mít položky, vlastnosti a události, stejně tak statické a nestatické metody. Můžete vytvořit instance struktur, předat je jako parametry, uložit je jako lokální proměnné nebo uložit je v položce jiného hodnotového nebo odkazového typu. Struktury také mohou implementovat rozhraní.

Hodnotové typy se také liší od tříd v několika ohledech. První, i když implicitně dědí z System.ValueType, nemohou přímo dědit z libovolného typu. Podobně jsou uzavřeny všechny hodnotové typy, což znamená, že žádný jiný typ nemůže být z nich odvozen. Také nevyžadují konstruktory.

Modul CLR (Common Language Runtime) pro každý hodnotový typ dodává odpovídající zabalený typ, což je třída, která má stejný stav a chování jako hodnotový typ. Instance hodnotového typu je zabalená, když je předána metodě, která přijímá parametr typu System.Object. Když se řízení vrací z volání metody, která akceptuje hodnotu jako parametr předaný odkazem, je instance nezabalená (to znamená, konvertována z instance třídy zpět na instanci hodnotového typu). Některé jazyky vyžadují použití speciální syntaxe, pokud je požadován zabalený typ; ostatní, když je to potřeba, použijí zabalený typ automaticky. Když definujete hodnotový typ, definujete zároveň zabalený i nezabalený typ.

Výčty

Výčet je hodnotový typ, který dědí přímo z System.Enum. Poskytuje alternativní názvy pro hodnoty nadřazeného primitivního typu. Typ výčet má množinu položek a název nadřazeného typu, který musí být jeden z předdefinovaných typů - signed nebo unsigned integer (například Byte, Int32 nebo UInt64). Položky jsou statické literální položky, z nichž každá představuje konstantu. Stejná hodnota může být přiřazena více položkám. V takovém případě musíte označit jednu z hodnot jako primární hodnotu výčtu a to z důvodu reflexe a převodu řetězce.

Můžete výčtu přiřadit hodnotu nadřazeného typu a naopak (žádné přetypování není požadováno modulem runtime). Můžete vytvořit instanci výčtu a volat metody System.Enum, stejně tak jakékoli metody definované u nadřízeného typu výčtu. Nicméně některé jazyky vám pravděpodobně neumožní předat výčet jako parametr, pokud je požadována instance nadřízeného typu (nebo naopak).

Následující omezení jsou také aplikována na výčty:

• Nemohou definovat jejich vlastní metody.

• Nemohou implementovat rozhraní.

• Nemohou definovat vlastnosti nebo události.

• Nemohou být obecné, pokud nejsou obecné pouze proto, že jsou vnořené do obecného typu. To znamená že výčet nemůže mít vlastní parametry typu.

  Poznámka
  Vnořené typy (včetně výčtů) vytvořené pomocí jazyků Visual Basic, C# a C++ zahrnují parametry typu všech ohraničujících obecných typů a jsou tudíž obecné, i když nemají vlastní parametry typu.Další informace naleznete v referenčním tématu Type.MakeGenericType v části Vnořené Typy.

Atribut FlagsAttribute označuje zvláštní druh výčtu nazývaný bitové pole. Samotný modul runtime nerozlišuje mezi tradičními výčty a bitovými poli, ale váš jazyk může. Pokud se provádí toto rozlišení, bitové operátory lze kvůli generování nepojmenovaných hodnot používat u bitových polí, ale ne výčtů. Výčty jsou obecně používány pro seznamy jedinečných prvků, například dny v týdnu, názvy zemí nebo oblastí a tak dále. Bitová pole jsou obecně používána pro seznamy vlastností nebo množství, které mohou nastat dohromady, například Red And Big And Fast.

Následující příklad ukazuje způsob použití bitových polí i tradičních výčtů.

Imports System.Collections.Generic

' A traditional enumeration of some root vegetables.
Public Enum SomeRootVegetables
   HorseRadish
   Radish
   Turnip
End Enum 

' A bit field or flag enumeration of harvesting seasons.
<Flags()> Public Enum Seasons
   None = 0
   Summer = 1
   Autumn = 2
   Winter = 4
   Spring = 8
   All = Summer Or Autumn Or Winter Or Spring
End Enum 

' Entry point.
Public Class Example
   Public Shared Sub Main()
      ' Hash table of when vegetables are available.
      Dim AvailableIn As New Dictionary(Of SomeRootVegetables, Seasons)()

      AvailableIn(SomeRootVegetables.HorseRadish) = Seasons.All
      AvailableIn(SomeRootVegetables.Radish) = Seasons.Spring
      AvailableIn(SomeRootVegetables.Turnip) = Seasons.Spring Or _
                                               Seasons.Autumn

      ' Array of the seasons, using the enumeration.
      Dim theSeasons() As Seasons = {Seasons.Summer, Seasons.Autumn, _
                                     Seasons.Winter, Seasons.Spring}

      ' Print information of what vegetables are available each season.
      For Each season As Seasons In theSeasons
         Console.WriteLine(String.Format( _
              "The following root vegetables are harvested in {0}:", _
              season.ToString("G")))
         For Each item As KeyValuePair(Of SomeRootVegetables, Seasons) In AvailableIn
            ' A bitwise comparison.
            If(CType(item.Value, Seasons) And season) > 0 Then
               Console.WriteLine("  " + _
                     CType(item.Key, SomeRootVegetables).ToString("G"))
            End If
         Next
      Next
   End Sub 
End Class 
' The example displays the following output:
'    The following root vegetables are harvested in Summer:
'      HorseRadish
'    The following root vegetables are harvested in Autumn:
'      Turnip
'      HorseRadish
'    The following root vegetables are harvested in Winter:
'      HorseRadish
'    The following root vegetables are harvested in Spring:
'      Turnip
'      Radish
'      HorseRadish

using System;
using System.Collections.Generic;

// A traditional enumeration of some root vegetables.
public enum SomeRootVegetables
{
    HorseRadish,
    Radish,
    Turnip
}

// A bit field or flag enumeration of harvesting seasons.
[Flags]
public enum Seasons
{
    None = 0,
    Summer = 1,
    Autumn = 2,
    Winter = 4,
    Spring = 8,
    All = Summer | Autumn | Winter | Spring
}

public class Example
{
   public static void Main()
   {
       // Hash table of when vegetables are available.
       Dictionary<SomeRootVegetables, Seasons> AvailableIn = new Dictionary<SomeRootVegetables, Seasons>();

       AvailableIn[SomeRootVegetables.HorseRadish] = Seasons.All;
       AvailableIn[SomeRootVegetables.Radish] = Seasons.Spring;
       AvailableIn[SomeRootVegetables.Turnip] = Seasons.Spring | 
            Seasons.Autumn;

       // Array of the seasons, using the enumeration.
       Seasons[] theSeasons = new Seasons[] { Seasons.Summer, Seasons.Autumn, 
            Seasons.Winter, Seasons.Spring };

       // Print information of what vegetables are available each season.
       foreach (Seasons season in theSeasons)
       {
          Console.Write(String.Format(
              "The following root vegetables are harvested in {0}:\n", 
              season.ToString("G")));
          foreach (KeyValuePair<SomeRootVegetables, Seasons> item in AvailableIn)
          {
             // A bitwise comparison.
             if (((Seasons)item.Value & season) > 0)
                 Console.Write(String.Format("  {0:G}\n", 
                      (SomeRootVegetables)item.Key));
          }
       }
   }
}
// The example displays the following output:
//    The following root vegetables are harvested in Summer:
//      HorseRadish
//    The following root vegetables are harvested in Autumn:
//      Turnip
//      HorseRadish
//    The following root vegetables are harvested in Winter:
//      HorseRadish
//    The following root vegetables are harvested in Spring:
//      Turnip
//      Radish
//      HorseRadish

Rozhraní

Rozhraní definuje kontrakt, který specifikuje relaci "lze provádět" nebo relaci "má". Rozhraní jsou často používána k implementaci funkcionality, jako je například porovnávání a řazení (rozhraní IComparable a IComparable<T> ), testování rovnosti (rozhraní IEquatable<T>) nebo spočítání položek v kolekci (rozhraní IEnumerable a IEnumerable<T>). Rozhraní mohou mít vlastnosti, metody a události. Všechny tyto položky jsou abstraktní členy; tedy, i když rozhraní definuje členy a jejich podpisy, ponechá je typu, který rozhraní implementuje, aby definoval funkcionalitu každého člena rozhraní. To znamená, že každá třída nebo struktura, která implementuje rozhraní musí poskytnout definici pro abstraktní členy deklarované v rozhraní. Rozhraní může vyžadovat, aby jakákoliv implementující třída nebo struktura také implementovala jedno nebo více jiných rozhraní.

Následující omezení jsou aplikována na rozhraní:

• Rozhraní může být deklarováno s jakoukoliv přístupností, ale všechny členy rozhraní musí mít veřejnou přístupnost.

• Rozhraní nemohou definovat konstruktory.

• Rozhraní nemohou definovat položky.

• Rozhraní může definovat pouze členy instance. Nemohou definovat statické členy.

Každý jazyk musí stanovit pravidla mapování implementace na rozhraní, které vyžaduje člen. Protože více než jedno rozhraní může deklarovat člena se stejnou signaturou a tyto členy mohou mít odlišnou implementaci.

Delegáti

Delegáti jsou odkazové typy sloužící k podobnému účelu jako ukazatelé na funkci v jazyce C++. Používají se pro zpětné volání funkcí v rozhraní .NET Framework a obslužné rutiny událostí. Na rozdíl od ukazatelů na funkce jsou delegáti zabezpečeni, ověřitelní a typově bezpeční. Typ delegát může představovat libovolnou metodu instance nebo statickou metodu, která má kompatibilní signaturu.

Parametr delegáta je kompatibilní s odpovídajícím parametrem metody, pokud je typ parametru delegáta více omezující než typ parametru metody. Toto zaručuje, že argument předaný delegátovi může být bezpečně předán metodě.

Podobně je kompatibilní návratový typ delegáta s návratovým typem metody. A to v případě, že je návratový typ metody více omezující než návratový typ delegáta. Toto zaručuje, že návratová hodnota metody může být bezpečně přetypovaná na návratový typ delegáta.

Například delegát, který má parametr typu IEnumerable a návratový typ Object může představovat metodu, která má parametr typu Object a návratovou hodnotu typu IEnumerable. Další informace a příklady kódu naleznete v tématu Delegate.CreateDelegate(Type, Object, MethodInfo).

Delegát je označován jako vázaný na metodu, kterou představuje. Vedle toho, že delegát může být vázán na metodu, tak může být také vázán na objekt. Objekt představuje první parametr metody a je předán metodě pokaždé, když je vyvolán delegát. Jestliže je metoda metodou instance, tak vázaný objekt je předán jako implicitní parametr this (Me v jazyce Visual Basic); pokud je metoda statická, tak je objekt předán jako první formální parametr metody a signatura delegáta musí odpovídat zbývajícím parametrům. Další informace a příklady kódu naleznete v tématu System.Delegate.

Všichni delegáti dědí z System.MulticastDelegate, který dědí z System.Delegate. Jazyky C#, Visual Basic a C++ neumožňují dědičnost z těchto typů. Místo toho poskytují klíčová slova pro deklarování delegátů.

Protože delegáti dědí z MulticastDelegate, tak delegát má seznam vyvolání, což je seznam metod, které delegát reprezentuje a které jsou spouštěny, když je delegát vyvolán. Všechny metody v seznamu obdrží argumenty poskytované při vyvolání delegáta.

Poznámka
Návratová hodnota není definována pro delegáta, který má více než jednu metodu v jeho vyvolávacím seznamu. Dokonce i v případě, že delegát má návratový typ.

V mnoha případech, jako je třeba zpětné volání metod, delegát představuje pouze jednu metodu. V takovém případě musíte obstarat pouze vytvoření a vyvolání delegáta.

Pro delegáty, kteří reprezentují několik metod, rozhraní .NET Framework poskytuje metody tříd delegátů Delegate a MulticastDelegate pro podporu operací, jako je přidání metody do seznamu vyvolání tohoto delegáta (metoda Delegate.Combine), odebrání metody (metoda Delegate.Remove) a získání seznamu vyvolání (metoda Delegate.GetInvocationList).

Poznámka
Není nutné používat tyto metody pro delegáty obsluhy událostí v jazycích C#, C++ a Visual Basic, protože tyto jazyky poskytují syntaxi pro přidávání a odebírání obslužných rutin událostí.

Zpět na začátek

Definice typů

Definice typu zahrnuje následující:

• Libovolné atributy definované u typu.

• Přístupnost typu (viditelnost).

• Název typu.

• Základní typ náležící typu.

• Jakékoliv rozhraní implementované typem.

• Definice pro každý člen typu.

Atributy

Atributy poskytují další metadata definované uživatelem. Nejčastěji se používají pro ukládání dodatečných informací o typu v sestavení nebo pro úpravu chování člena typu buď v době návrhu nebo v běhovém prostředí.

Atributy jsou samotné třídy, které dědí z třídy System.Attribute. Jazyky, které podporují použití atributů mají svou vlastní syntaxi pro aplikování atributů na prvky jazyka. Atributy mohou být aplikovány téměř na libovolný element jazyka. Specifické prvky, na které lze aplikovat atribut jsou definovány třídou AttributeUsageAttribute, která je použita na danou třídu atributů.

Přístupnost typu

Všechny typy mají modifikátor, který řídí jejich přístupnost z jiných typů. Následující tabulka popisuje přístupnosti typu podporované modulem runtime.

Přístupnost	Popis
public	Typ je přístupný všem sestavením.
assembly	Typ je přístupný pouze uvnitř jeho sestavení.

Přístupnost vnořeného typu závisí na jeho doméně přístupnosti, která je určena deklarovanou přístupností člena a doménou přístupnosti bezprostředně nadřazeného typu. Doména přístupnosti vnořeného typu však nesmí přesáhnout přístupnost nadřazeného typu.

Doména přístupnosti vnořeného člena M, deklarovaného v typu T, uvnitř programu P, je definována takto (konstatujme, že člen M může být sám typ):

• Pokud je deklarovaná přístupnost člena M public, tak doména přístupnosti člena M je doména přístupnosti typu T.

• Pokud je deklarovaná přístupnost člena M protected internal, tak doména přístupnosti člena M je průsečík domény přístupnosti typu T s textem programu P a textem programu libovolného typu odvozeného z typu T, deklarovaného mimo program P.

• Pokud je deklarovaná přístupnost člena M protected, tak doména přístupnosti člena M je průsečík domény přístupnosti typu T s textem programu T a libovolného typu odvozeného z T.

• Pokud je deklarovaná přístupnost člena M internal, tak doména přístupnosti člena M je průsečík domény přístupnosti typu T s textem programu P.

• Pokud je deklarovaná přístupnost člena M private, tak doména přístupnosti člena M je text programu T.

Názvy typů

Specifikace CTS (Common Type System) vynucuje pouze dvě omezení na názvy:

• Všechny názvy jsou kódovány jako řetězce (16bitových) znaků Unicode.

• Názvy nejsou oprávněny mít vloženou (16bitovou) hodnotu 0x0000.

Většina jazyků však zavádí další omezení pro názvy typů. Všechna porovnání jsou prováděna byte po bajtu a proto jsou nezávislá na nastavení národního prostředí a citlivá na velikost písmen.

Přestože typ může odkazovat na typy z jiných modulů a sestavení, tak musí být plně definován uvnitř jednoho modulu rozhraní .NET Framework. (V závislosti na podpoře kompilátoru však může být rozdělen do více souborů zdrojového kódu.) Názvy typů musí být jedinečné uvnitř oboru názvu. Aby byl typ plně identifikován, musí být název typu určen pomocí oboru názvu, který obsahuje implementaci daného typu.

Základní typy a rozhraní

Typ může zdědit hodnoty a chování od jiného typu. Specifikace CTS (Common Type System) neumožňuje typům dědit z více než jednoho základního typu.

Typ může implementovat libovolný počet rozhraní. Aby typ mohl implementovat rozhraní, musí implementovat všechny virtuální členy rozhraní. Virtuální metoda může být implementována odvozeným typem a vyvolána staticky nebo dynamicky.

Zpět na začátek

Členy typu

Runtime modul umožňuje definovat členy vašeho typu, které specifikují chování a stav tohoto typu. Členy typu zahrnují následující:

• Pole

• Vlastnosti

• Metody

• Konstruktory

• Události

• Vnořené typy

Pole

Položka popisuje a obsahuje část stavu typu. Položky mohou být libovolného typu. Daný typ však musí být podporován modulem runtime. Nejčastěji jsou položky buď private nebo protected, takže jsou přístupné pouze uvnitř třídy nebo z odvozené třídy. Pokud hodnota položky může být změněna mimo její typ, tak se obvykle používá přistupující objekt množiny vlastností. Veřejně vystavené položky jsou obvykle jen pro čtení a mohou mít dva typy:

• Konstanty, jejichž hodnoty jsou přiřazeny v době návrhu. Jde o statické členy třídy, přestože nejsou definovány pomocí klíčového slova static (Shared v jazyce Visual Basic).

• Proměnné určené jen pro čtení, jejichž hodnoty mohou být přiřazeny v konstruktoru třídy.

Následující příklad znázorňuje tyto dva způsoby použití položek určených jen pro čtení.

Public Class Constants
   Public Const Pi As Double = 3.1416
   Public ReadOnly BirthDate As Date

   Public Sub New(birthDate As Date)
      Me.BirthDate = birthDate
   End Sub
End Class

Public Module Example
   Public Sub Main()
      Dim con As New Constants(#8/18/1974#)
      Console.WriteLine(Constants.Pi.ToString())
      Console.WriteLine(con.BirthDate.ToString("d"))
   End Sub
End Module
' The example displays the following output if run on a system whose current
' culture is en-US:
'    3.1417
'    8/18/1974

using System;

public class Constants
{
   public const double Pi = 3.1416;
   public readonly DateTime BirthDate;

   public Constants(DateTime birthDate)
   {
      this.BirthDate = birthDate;
   }
}

public class Example
{
   public static void Main()
   {
      Constants con = new Constants(new DateTime(1974, 8, 18));
      Console.Write(Constants.Pi + "\n");
      Console.Write(con.BirthDate.ToString("d") + "\n");
   }
}
// The example displays the following output if run on a system whose current
// culture is en-US:
//    3.1417
//    8/18/1974

Vlastnosti

Vlastnosti pojmenovávají hodnotu nebo stav typu a definují metody, které vrátí nebo nastaví hodnotu vlastnosti. Vlastnosti mohou být primitivní typy, kolekce primitivních typů, uživatelem definované typy nebo kolekce uživatelem definovaných typů. Vlastnosti jsou často používány k udržení nezávislosti veřejného rozhraní typu od aktuální reprezentace typu. Toto umožňuje vlastnostem vyjadřovat hodnoty, které nejsou uloženy přímo ve třídě (například, když vlastnost vrací vypočítanou hodnotu) nebo provádět ověření před tím, než jsou hodnoty přiřazeny k privátním položkám. Následující příklad znázorňuje druhý případ.

Public Class Person
   Private m_Age As Integer

   Public Property Age As Integer
      Get
         Return m_Age
      End Get
      Set
         If value < 0 Or value > 125 Then
            Throw New ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.")
         Else
            m_Age = value
         End If
      End Set
   End Property
End Class

using System;

public class Person
{
   private int m_Age;

   public int Age
   { 
      get { return m_Age; }
      set {
         if (value < 0 || value > 125)
         {
            throw new ArgumentOutOfRangeException("The value of the Age property must be between 0 and 125.");
         }
         else
         {
            m_Age = value;
         }         
      }
   }
}

Kromě zahrnutí samotné vlastnosti, jazyk MSIL (Microsoft Intermediate Language) pro typ obsahující čitelnou vlastnost také zahrnuje metodu get_propertyname. Pro typ, který obsahuje zapisovatelnou vlastnosti, jazyk MSIL zahrnuje metodu set_propertyname.

Metody

Metoda popisuje operace, které jsou k dispozici u typu. Signatura metody specifikuje přípustné typy všech jejích parametrů a její návratovou hodnotu.

Přestože většina metod definuje přesný počet parametrů, které jsou požadovány pro volání metody, některé metody podporují proměnný počet parametrů. Výsledný deklarovaný parametr těchto metod je označen atributem ParamArrayAttribute. Kompilátory jazyka obvykle poskytují klíčové slovo, jako je například params v jazyce C# a ParamArray v jazyce Visual Basic, které činí explicitní použití atributu ParamArrayAttribute zbytečným.

Konstruktory

Konstruktor je zvláštní druh metody, která vytváří nové instance třídy nebo struktury. Stejně jako jakákoli jiná metoda, konstruktor může obsahovat parametry; ale konstruktory nemají návratovou hodnotu (to znamená, že vrací hodnotu void).

Pokud zdrojový kód třídy explicitně nedefinuje konstruktor, kompilátor obsahuje výchozí konstruktor (bez parametrů). Nicméně pokud zdrojový kód třídy definuje pouze konstruktor s parametry, kompilátory jazyků Visual Basic a C# negenerují tento bezparametrický konstruktor.

Pokud zdrojový kód struktury definuje konstruktory, musí se jednat o konstruktory s parametry; struktura nemůže definovat výchozí (bezparametrový) konstruktor. Kompilátory negenerují bezparametrické konstruktory pro struktury nebo jiné hodnotové typy. Všechny hodnotové typy mají implicitní výchozí konstruktor. Tento konstruktor je implementován modulem CLR (Common Language Runtime) a inicializuje všechny položky struktury na jejich výchozí hodnoty.

Události

Událost definuje situaci, na kterou může být odpovězeno. Rovněž definuje metody pro přihlášení k odběru události, metody pro odhlášení odběru a metody pro vyvolání události. Události jsou často používány k tomu, aby informovaly jiné typy o změně stavu. Další informace naleznete v tématu Zpracování a vyvolávání událostí.

Vnořené typy

Vnořený typ je typ, který je členem některého jiného typu. Vnořené typy by měly být úzce spojeny s jejich nadřazeným typem a nesmí být užitečné jako všeobecný typ. Vnořené typy jsou užitečné v případě, že deklarující typ používá a vytváří instance vnořeného typu a použití vnořeného typu není zveřejněno ve veřejných členech.

Vnořené typy jsou matoucí pro některé vývojáře a neměly by být veřejně viditelné pokud neexistuje závažný důvod pro jejich viditelnost. V dobře navržené knihovně by vývojáři měli použít vnořené typy jen zřídka, a to pro vytvoření instancí objektů nebo deklaraci proměnných.

Zpět na začátek

Charakteristiky členů typu

Specifikace CTS (Common Type System) umožňuje členům typu mít různé vlastnosti (charakteristiky); po jazycích však není požadována podpora všech těchto vlastností. Následující tabulka popisuje vlastnosti členů.

Vlastnost	Může být aplikována na	Popis
abstract	Metody, vlastnosti a události.	Typ neposkytuje implementaci metody. Typy, které dědí nebo implementují abstraktní metody musí poskytnout implementaci pro danou metodu. Jediná výjimka je v případě, že odvozený typ je sám abstraktním typem. Všechny abstraktní metody jsou virtuální.
private, family, assembly, family a assembly, family nebo assembly, public	Všechny	Definuje dostupnost člena: private Přístupný pouze uvnitř stejného typu jako člen nebo uvnitř vnořeného typu. family Přístupný uvnitř stejného typu jako člen a z odvozeného typu, který z tohoto dědí. assembly Přístupný pouze v sestavení, ve kterém je typ definován. family a assembly Přístupný pouze z typů, které jsou způsobilé pro family a assembly přístup. family nebo assembly Přístupný pouze z typů, které jsou způsobilé buď pro family přístup nebo assembly přístup. public Dostupný z libovolného typu.
final	Metody, vlastnosti a události.	Virtuální metoda nemůže být přepsána v odvozeném typu.
initialize-only	Položky	Hodnota může být pouze inicializována, nelze ji po inicializaci zapsat.
instance	Položky, metody, vlastnosti, a události	Pokud člen není označen jako static (C# a C++), Shared (Visual Basic), virtual (C# a C++) nebo Overridable (Visual Basic), pak je členem instance (není zde žádné klíčové slovo instance). V paměti bude tolik kopií takovýchto členů, jako je zde objektů, které je používají.
literál	Položky	Hodnota přiřazená k položce je pevná, je známá v době kompilace předdefinovaného hodnotového typu. Položky typu literál jsou někdy označovány jako konstanty.
newslot or override	Všechna	Definuje způsob interakce člena se zděděnými členy, které mají stejnou signaturu: newslot Skryje zděděné členy, které mají stejnou signaturu. override Nahradí definici zděděné virtuální metody. Výchozí hodnota je newslot.
static	Položky, metody, vlastnosti, a události	Člen náleží k typu, ve kterém je definován a ne k určité instanci typu; člen existuje i když instance typu není vytvořena a je sdílen mezi všemi instancemi typu.
virtual	Metody, vlastnosti a události.	Metoda může být implementována odvozeným typem a vyvolána staticky nebo dynamicky. Pokud je použito dynamické vyvolání, tak typ instance, která provádí volání v době běhu (spíše než známý typ v době kompilace) určuje, která implementace metody je volána. Aby mohla být virtuální metoda vyvolána staticky, možná bude muset být proměnná přetypována na typ, který používá požadovanou verzi metody.

Přetěžování

Každý člen typu má jedinečnou signaturu. Signatury metod se skládají z názvu metody a seznamu parametrů (pořadí a typy argumentů metody). Lze definovat více metod se stejným názvem, dokud se liší jejich podpisy. Když jsou definovány dvě nebo více metod se stejným názvem, tak se o dané metodě říká, že je přetížena. Například ve třídě System.Char, je přetížena metoda IsDigit. Jedna metoda má parametr typu Char. Jiná metoda má parametry typu String a Int32.

Poznámka
Návratový typ není považován za součást signatury metody.To znamená, že metody nemohou být přetíženy, pokud se liší pouze návratovým typem.

Dědění, přepisování a skrývání členů

Odvozený typ zdědí všechny členy jeho rodičovského typu; to znamená, že všechny členy jsou, jak definovány, tak k dispozici pro odvozený typ. Chování a vlastnosti zděděných členů mohou být upraveny dvěma způsoby:

• Odvozený typ může skrýt zděděný člen tak, že definuje nového člena se stejnou signaturou. Toto může být provedeno za účelem udělat z dříve veřejného člena soukromý nebo definovat nové chování pro zděděnou metodu, která je označena jako final.

• Odvozený typ může přepsat zděděnou virtuální metodu. Přepsání metody poskytuje novou definici metody, která bude spíše vyvolána v době běhu na základě typu hodnoty než na základě typu proměnné, který je známý v době kompilace. Metoda může přepsat virtuální metodu pouze v případě, že virtuální metoda není označená jako final a nová metoda je přinejmenším stejně dostupná jako ta virtuální.

Zpět na začátek

Viz také

Odkaz

.NET Framework Class Library

Koncepty

Společný jazykový modul runtime (CLR )