Gyakori típusrendszer

A közös típusrendszer meghatározza, hogy a típusok hogyan deklarálhatók, használhatók és kezelhetők a közös nyelvi futtatókörnyezetben, és fontos része a futtatókörnyezet nyelvközi integrációs támogatásának is. A gyakori típusrendszer a következő funkciókat hajtja végre:

• Létrehoz egy keretrendszert, amely lehetővé teszi a nyelvközi integrációt, a típusbiztonságot és a nagy teljesítményű kódvégrehajtást.

• Objektumorientált modellt biztosít, amely számos programozási nyelv teljes megvalósítását támogatja.

• Meghatározza azokat a szabályokat, amelyeket a nyelveknek követnie kell, ami segít biztosítani, hogy a különböző nyelveken írt objektumok kommunikálhassanak egymással.

• Olyan kódtárat biztosít, amely az alkalmazásfejlesztéshez használt primitív adattípusokat (például Boolean, Byte, Char, Int32és UInt64) tartalmazza.

Típusok a .NET-ben

A .NET-ben minden típus értéktípus vagy referenciatípus.

Az értéktípusok olyan adattípusok, amelyek objektumait az objektum tényleges értéke jelöli. Ha egy értéktípus egy példánya egy változóhoz van rendelve, az adott változó megkapja az érték friss másolatát.

A referenciatípusok olyan adattípusok, amelyek objektumait az objektum tényleges értékére mutató hivatkozás (egy mutatóhoz hasonló) jelöli. Ha egy változóhoz egy referenciatípus van hozzárendelve, az a változó az eredeti értékre hivatkozik (erre mutat). Nincs másolat.

A .NET általános típusrendszere a következő öt típuskategóriát támogatja:

• Osztályok
• Struktúrák
• Számbavételek
• Felületek
• Küldöttek

Osztályok

Az osztály olyan referenciatípus, amely közvetlenül egy másik osztályból származtatható, és implicit módon származik.System.Object Az osztály meghatározza azokat a műveleteket, amelyeket egy objektum (amely az osztály egy példánya) végrehajthat (metódusokat, eseményeket vagy tulajdonságokat), valamint az objektum által tartalmazott adatokat (mezőket). Bár egy osztály általában magában foglalja a definíciót és a megvalósítást is (ellentétben az interfészekkel, amelyek például csak implementálás nélküli definíciót tartalmaznak), egy vagy több olyan taggal rendelkezhet, amelyek nem rendelkeznek implementációval.

Az alábbi táblázat néhány olyan jellemzőt ismertet, amelyekkel egy osztály rendelkezhet. Minden olyan nyelv, amely támogatja a futtatókörnyezetet, jelzi, hogy egy osztály vagy osztálytag rendelkezik egy vagy több ilyen jellemzővel. A .NET-et célzó egyes programozási nyelvek azonban nem feltétlenül teszik elérhetővé ezeket a jellemzőket.

Azok az osztálytagok, amelyek nem rendelkeznek implementációval, absztrakt tagok. Egy vagy több absztrakt taggal rendelkező osztály maga is absztrakt; új példányok nem hozhatók létre. A futtatókörnyezetet megcélozó nyelvek némelyike lehetővé teszi, hogy egy osztályt absztraktként jelöljön meg, még akkor is, ha egyik tag sem absztrakt. Absztrakt osztályt akkor használhat, ha olyan alapszintű funkciókat szeretne beágyazni, amelyeket a származtatott osztályok adott esetben örökölhetnek vagy felülbírálhatnak. A nem absztrakt osztályokat konkrét osztályoknak nevezzük.

Egy osztály tetszőleges számú interfészt implementálhat, de csak egy alaposztálytól System.Objectörökölhet, és ezektől az osztályok implicit módon örökölhetnek. Minden osztálynak rendelkeznie kell legalább egy konstruktorával, amely inicializálja az osztály új példányait. Ha nem határoz meg explicit módon konstruktort, a legtöbb fordító automatikusan paraméter nélküli konstruktort biztosít.

Struktúrák

A struktúra olyan értéktípus, amely implicit módon System.ValueTypeszármazik , és amelyből származik System.Object. A struktúra hasznos azoknak az értékeknek az ábrázolásához, amelyek memóriaigénye kicsi, és az értékeket értékenkénti paraméterként adja át az erősen gépelt paraméterekkel rendelkező metódusoknak. A .NET-ben minden primitív adattípus (Boolean, , Byte, CharDateTime, DoubleDecimal, , Int16Int32, Int64, SByte, Single, UInt16, , UInt32és UInt64) struktúrákként van definiálva.

Az osztályokhoz hasonlóan a struktúrák is meghatározzák az adatokat (a struktúra mezőit) és az adatokon végrehajtható műveleteket (a struktúra módszereit). Ez azt jelenti, hogy metódusokat hívhat meg a struktúrákon, beleértve az osztályon és System.ValueType az System.Object osztályokon definiált virtuális metódusokat, valamint az értéktípuson definiált metódusokat. Más szóval a struktúrák lehetnek mezők, tulajdonságok és események, valamint statikus és nem statikus módszerek. Létrehozhat struktúrák példányait, átadhatja őket paraméterekként, tárolhatja őket helyi változókként, vagy tárolhatja őket egy másik értéktípusú vagy referenciatípusú mezőben. A struktúrák interfészeket is implementálhatnak.

Az értéktípusok több szempontból is különböznek az osztályoktól. Először is, bár implicit módon örökölnek System.ValueType, nem örökölhetnek közvetlenül semmilyen típusból. Hasonlóképpen, az összes értéktípus zárolva van, ami azt jelenti, hogy más típus nem származtatható belőlük. Nem igényelnek konstruktorokat sem.

Minden értéktípushoz a közös nyelvi futtatókörnyezet egy megfelelő dobozos típust biztosít, amely egy olyan osztály, amelynek állapota és viselkedése megegyezik az értéktípussal. Az értéktípus egy példánya akkor van bejelölve, ha egy metódusnak adja át, amely elfogadja a típusparamétert System.Object. Nincs megadva (azaz egy osztály egy példányából vissza lesz konvertálva egy értéktípus egy példányára), amikor a vezérlőelem egy metódushívásból ad vissza, amely egy értéktípust fogad el hivatkozási paraméterként. Egyes nyelvek speciális szintaxist igényelnek, ha a dobozos típusra van szükség; mások automatikusan használják a dobozos típust, amikor szükség van rá. Értéktípus definiálásakor a dobozos és a nem dobozolt típust is definiálja.

Enumerálások

Az enumerálás olyan értéktípus, amely közvetlenül örököl System.Enum , és alternatív neveket biztosít egy mögöttes primitív típus értékeihez. Az enumerálási típusnak van egy neve, egy mögöttes típusa, amelynek az egyik beépített aláírt vagy aláíratlan egész típusúnak (például Byte, Int32vagy UInt64) és mezőkészletnek kell lennie. A mezők statikus konstans mezők, amelyek mindegyike állandót jelöl. Ugyanez az érték több mezőhöz is hozzárendelhető. Ha ez történik, az egyik értéket meg kell jelölnie elsődleges számbavételi értékként a tükröződés és a sztringátalakítás esetében.

Az alapul szolgáló típus értékét hozzárendelheti egy enumeráláshoz, és fordítva (a futtatókörnyezetnek nincs szüksége leadásra). Létrehozhat egy enumerálási példányt, és meghívhatja a metódusokat System.Enum, valamint az enumerálás alapjául szolgáló típuson definiált metódusokat. Előfordulhat azonban, hogy egyes nyelvek nem engedélyezik az enumerálás paraméterként való átadását, ha az alapul szolgáló típusú példányra van szükség (vagy fordítva).

Az enumerálásokra a következő további korlátozások vonatkoznak:

• Nem határozhatják meg a saját metódusaikat.

• Nem implementálhatnak interfészeket.

• Nem definiálhatnak tulajdonságokat vagy eseményeket.

• Nem lehetnek általánosak, kivéve, ha csak azért általánosak, mert egy általános típusba vannak beágyazva. Vagyis az enumerálás nem rendelkezhet saját típusparaméterekkel.

  Feljegyzés

  A Visual Basic, C# és C++ használatával létrehozott beágyazott típusok (beleértve az enumerációkat is) tartalmazzák az összes beágyazott általános típus típusparamétereit, ezért általánosak akkor is, ha nem rendelkeznek saját típusparaméterekkel. További információ: "Beágyazott típusok" a Type.MakeGenericType referenciatémakörben.

Az FlagsAttribute attribútum egy speciális enumerálási típust, úgynevezett bitmezőt jelöl. Maga a futtatókörnyezet nem tesz különbséget a hagyományos számbavételek és a bitmezők között, de a nyelv ezt megteheti. Ha ez a különbségtétel történik, a bitenkénti operátorok bitenkénti mezőkön, de enumerálásokon nem használhatók névtelen értékek létrehozásához. Az enumerálásokat általában egyedi elemek listáihoz használják, például a hét napjaihoz, az ország- vagy régiónevekhez stb. A bitmezőket általában olyan tulajdonságok vagy mennyiségek listázására használják, amelyek kombinálva fordulhatnak elő, például Red And Big And Fast.

Az alábbi példa a bitmezők és a hagyományos enumerációk használatát mutatja be.

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

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

Interfészek

Az interfész olyan szerződést határoz meg, amely "can do" vagy "has a" kapcsolatot határoz meg. A felületeket gyakran használják olyan funkciók implementálásához, mint például a összehasonlítása és rendezése (az IComparable és IComparable<T> interfészek), az egyenlőség tesztelése (az IEquatable<T> interfész), vagy a gyűjtemény elemeinek (és IEnumerable IEnumerable<T> interfészeinek) felsorolása. Az interfészek rendelkezhetnek tulajdonságokkal, metódusokkal és eseményekkel, amelyek mindegyike absztrakt tag; vagyis bár a felület meghatározza a tagokat és azok aláírását, az interfészt megvalósító típusra hagyja, hogy meghatározza az egyes felülettagok funkcióit. Ez azt jelenti, hogy az interfészt megvalósító osztályoknak vagy struktúráknak definíciókat kell megadniuk a felületen deklarált absztrakt tagok számára. Az interfészek implementálási osztályt vagy struktúrát igényelhetnek egy vagy több más interfész implementálásához is.

Az interfészekre a következő korlátozások vonatkoznak:

• A felület bármilyen akadálymentességgel deklarálható, de a felület tagjainak nyilvános hozzáféréssel kell rendelkezniük.
• Az interfészek nem definiálnak konstruktorokat.
• A felületek nem definiálnak mezőket.
• Az interfészek csak a példánytagokat definiálhatják. Nem definiálhatnak statikus tagokat.

Minden nyelvnek szabályokat kell biztosítania a végrehajtásnak a tagot igénylő felülethez való leképezéséhez, mivel egynél több felület is deklarálhat egy tagot ugyanazzal az aláírással, és ezek a tagok külön implementációkkal rendelkezhetnek.

Delegáltak

A meghatalmazottak olyan referenciatípusok, amelyek a C++ függvénymutatóihoz hasonló célt szolgálnak. A .NET eseménykezelőihez és visszahívási függvényeihez használják őket. A függvénymutatókkal ellentétben a meghatalmazottak biztonságosak, ellenőrizhetők és biztonságosak. A meghatalmazotti típus bármilyen olyan példánymetódust vagy statikus metódust jelölhet, amely kompatibilis aláírással rendelkezik.

A meghatalmazott paramétere kompatibilis a metódus megfelelő paraméterével, ha a delegálási paraméter típusa szigorúbb, mint a metódusparaméter típusa, mivel ez garantálja, hogy a delegáltnak átadott argumentum biztonságosan átadható a metódusnak.

Hasonlóképpen, a delegált visszatérési típusa kompatibilis a metódus visszatérési típusával, ha a metódus visszatérési típusa korlátozóbb, mint a delegált visszatérési típusa, mivel ez garantálja, hogy a metódus visszatérési értéke biztonságosan átvehető a delegált visszatérési típusára.

Egy olyan delegált például, amely típusparaméterrel IEnumerable és visszatérési Object típussal rendelkezik, olyan metódust jelölhet, amely típusparaméterrel Object és típusértékkel IEnumerablerendelkezik. További információ és példakód: Delegate.CreateDelegate(Type, Object, MethodInfo).

A meghatalmazottnak azt mondják, hogy az általa képviselt metódushoz van kötve. A metódushoz való kötődés mellett a meghatalmazottak egy objektumhoz is köthetők. Az objektum a metódus első paraméterét jelöli, és minden alkalommal átadja a metódusnak, amikor meghívja a delegáltat. Ha a metódus példánymetódus, a kötött objektum implicit this paraméterként lesz átadva (Me a Visual Basicben); ha a metódus statikus, az objektumot a metódus első formális paramétereként adja át, és a delegált aláírásnak meg kell egyeznie a többi paramétersel. További információ és példakód: System.Delegate.

Az összes meghatalmazott örökli a elemet, amelytől System.MulticastDelegateörököl System.Delegate. A C#, a Visual Basic és a C++ nyelv nem engedélyezi az ilyen típusú öröklést. Ehelyett kulcsszavakat biztosítanak a meghatalmazottak deklarálására.

Mivel a meghatalmazottak öröklődnek, MulticastDelegatea meghatalmazottaknak van egy meghívási listája, amely azoknak a metódusoknak a listája, amelyeket a meghatalmazott képvisel, és amelyeket a meghatalmazott meghívásakor hajtanak végre. A listában szereplő összes metódus megkapja a meghatalmazott meghívásakor megadott argumentumokat.

Sok esetben, például visszahívási metódusok esetén a meghatalmazott csak egy metódust jelöl, és az egyetlen teendő a meghatalmazott létrehozása és meghívása.

A több metódust képviselő meghatalmazottak esetében a .NET az és a Delegate MulticastDelegate delegált osztályok metódusait biztosítja a műveletek támogatására, például metódus hozzáadását a meghatalmazott meghívási listájához (a Delegate.Combine metódushoz), eltávolít egy metódust (a Delegate.Remove metódust), és lekéri a meghívási listát (a Delegate.GetInvocationList metódust).

Típusdefiníciók

A típusdefiníció a következőket tartalmazza:

• A típuson definiált attribútumok.
• A típus akadálymentessége (láthatósága).
• A típus neve.
• A típus alaptípusa.
• A típus által implementált interfészek.
• Definíciók a típus egyes tagjaihoz.

Attribútumok

Az attribútumok további felhasználó által definiált metaadatokat biztosítanak. Leggyakrabban arra használják őket, hogy egy típussal kapcsolatos további információkat tároljanak a szerelvényben, vagy hogy módosítsák a típustagok viselkedését a tervezési vagy futásidejű környezetben.

Az attribútumok maguktól az osztályoktól System.Attributeöröklődnek. Az attribútumok használatát támogató nyelvek saját szintaxissal rendelkeznek az attribútumok nyelvelemre való alkalmazásához. Az attribútumok szinte bármilyen nyelvi elemre alkalmazhatók; az adott attribútumosztályra alkalmazott elemek határozzák meg azokat az AttributeUsageAttribute elemeket, amelyekre az attribútum alkalmazható.

Kisegítő lehetőségek beírása

Minden típus rendelkezik egy módosítóval, amely szabályozza a más típusok akadálymentességét. Az alábbi táblázat a futtatókörnyezet által támogatott típus-hozzáférési képességeket ismerteti.

A beágyazott típus akadálymentessége az akadálymentességi tartományától függ, amelyet a tag deklarált akadálymentessége és az azonnal tartalmazó típus akadálymentességi tartománya határoz meg. A beágyazott típus akadálymentességi tartománya azonban nem haladhatja meg az azt tartalmazó típushoz tartozó tartományt.

A programon P belüli típusban T deklarált beágyazott tag M akadálymentességi tartománya az alábbiak szerint van definiálva (nem feledve, hogy M maga is típus lehet):

• Ha a deklarált akadálymentesség M az public, akkor az akadálymentességi tartomány M az akadálymentességi Ttartomány.

• Ha a deklarált akadálymentesség M azprotected internal, akkor az akadálymentességi tartomány T M metszéspontja a programszöveggel P és a külső Pdeklaráltból T származtatott bármilyen típusú programszöveggel.

• Ha a deklarált akadálymentesség az, akkor az akadálymentességi tartomány M az akadálymentességi tartomány metszete T a program szövegével T és az abból származtatott bármilyen típussalT.protectedM

• Ha a deklarált akadálymentesség M az internal, akkor az akadálymentességi tartomány M az akadálymentességi tartomány és a program szövegének T metszete P.

• Ha a deklarált akadálymentesség M az private, akkor az akadálymentességi tartomány M a program szövege T.

Gépelje be a neveket

A közös típusrendszer csak két korlátozást ír elő a nevekre:

• Minden név Unicode (16 bites) karaktersorozatként van kódolva.
• A nevek nem rendelkezhetnek beágyazott (16 bites) 0x0000 értékkel.

A legtöbb nyelv azonban további korlátozásokat vezet be a típusnevekre. Minden összehasonlítás bájtonként történik, ezért a kis- és nagybetűk megkülönböztetése és területi beállítása független.

Bár egy típus hivatkozhat más modulok és szerelvények típusaira, egy típust teljes mértékben definiálni kell egy .NET-modulon belül. (A fordító támogatásától függően azonban több forráskódfájlra is felosztható.) A típusneveknek csak névtéren belül kell egyedinek lenniük. A típus teljes azonosításához a típusnevet a típus implementálását tartalmazó névtérnek kell minősítenie.

Alaptípusok és interfészek

Egy típus egy másik típustól örökölhet értékeket és viselkedéseket. A gyakori típusrendszer nem teszi lehetővé, hogy a típusok egynél több alaptípustól örököljenek.

Egy típus tetszőleges számú illesztőt implementálhat. Az interfész implementálásához egy típusnak implementálnia kell az adott felület összes virtuális tagját. A virtuális metódusok származtatott típussal implementálhatók, és statikusan vagy dinamikusan hívhatók meg.

Tagok beírása

A futtatókörnyezet lehetővé teszi a típus tagjainak definiálását, amely meghatározza egy típus viselkedését és állapotát. A típustagok a következők:

• Mezők
• Tulajdonságok
• Módszerek
• Konstruktorok
• Események
• Beágyazott típusok

Mezők

Egy mező a típus állapotának egy részét írja le és tartalmazza. A mezők bármilyen típusúak lehetnek, amelyeket a futtatókörnyezet támogat. A mezők leggyakrabban vagy private protectedúgy vannak, hogy csak az osztályon belülről vagy származtatott osztályból érhetők el. Ha egy mező értéke a típusán kívülről módosítható, általában egy tulajdonságkészlet-tartozékot használ. A nyilvánosan közzétett mezők általában írásvédettek, és két típusból állnak:

• Állandók, amelyek értéke a tervezéskor van hozzárendelve. Ezek egy osztály statikus tagjai, bár nem a static (Shared Visual Basic) kulcsszóval vannak definiálva.
• Írásvédett változók, amelyek értékei hozzárendelhetők az osztálykonstruktorhoz.

Az alábbi példa az írásvédett mezők két használatát szemlélteti.

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.1416
//    8/18/1974

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.1416
'    8/18/1974

Tulajdonságok

A tulajdonság a típus értékét vagy állapotát adja meg, és meghatározza a tulajdonság értékének lekérésére vagy beállítására szolgáló módszereket. A tulajdonságok lehetnek primitív típusok, primitív típusok gyűjteményei, felhasználó által definiált típusok vagy felhasználó által definiált típusok gyűjteményei. A tulajdonságok gyakran arra szolgálnak, hogy a típus nyilvános felülete független legyen a típus tényleges ábrázolásától. Ez lehetővé teszi a tulajdonságok számára, hogy tükrözzék az osztályban közvetlenül nem tárolt értékeket (például amikor egy tulajdonság kiszámított értéket ad vissza), vagy hogy érvényesítse őket, mielőtt az értékeket privát mezőkhöz rendelik. Az alábbi példa az utóbbi mintát szemlélteti.

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

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

Az olvasható tulajdonságot tartalmazó típus közbülső nyelve (CIL) magában foglalja get_a tulajdonságnévmetódust , a írható tulajdonságot tartalmazó típus CIL-jének pedig egy set_tulajdonságnévmetódust .

Metódusok

A metódus a típuson elérhető műveleteket írja le. A metódus aláírása az összes paraméter és a visszatérési érték engedélyezett típusait határozza meg.

Bár a legtöbb metódus pontosan meghatározza a metódushívásokhoz szükséges paraméterek számát, egyes metódusok változó számú paramétert támogatnak. A metódusok végső deklarált paramétere az ParamArrayAttribute attribútummal van megjelölve. A nyelvfordítók általában olyan kulcsszót biztosítanak, például params a C#-ban és ParamArray a Visual Basicben, amely szükségtelen ParamArrayAttribute használatot tesz lehetővé.

Konstruktorok

A konstruktor egy speciális módszer, amely egy osztály vagy struktúra új példányait hozza létre. Mint minden más módszer, a konstruktor is tartalmazhat paramétereket; a konstruktorok azonban nem rendelkeznek visszatérési értékkel (azaz visszaadják void).

Ha egy osztály forráskódja nem definiál explicit módon konstruktort, a fordító tartalmaz egy paraméter nélküli konstruktort. Ha azonban egy osztály forráskódja csak paraméteres konstruktorokat határoz meg, a Visual Basic és a C# fordítói nem hoznak létre paraméter nélküli konstruktort.

Ha egy struktúra forráskódja konstruktorokat határoz meg, paramétereznünk kell őket; a struktúra nem definiálhat paraméter nélküli konstruktort, és a fordítók nem hoznak létre paraméter nélküli konstruktorokat struktúrákhoz vagy más értéktípusokhoz. Minden értéktípus rendelkezik implicit paraméter nélküli konstruktorsal. Ezt a konstruktort a közös nyelvi futtatókörnyezet implementálja, és inicializálja a struktúra összes mezőjét az alapértelmezett értékekkel.

esemény

Az esemény egy olyan incidenst határoz meg, amely megválaszolható, és metódusokat határoz meg az eseményre való feliratkozáshoz, a leiratkozáshoz és az esemény emeléséhez. Az események gyakran más típusú állapotváltozások tájékoztatására szolgálnak. További információ: Események.

Beágyazott típusok

A beágyazott típus olyan típus, amely más típus tagja. A beágyazott típusokat szorosan kell összekapcsolni a bennük található típussal, és általános célú típusként nem lehet hasznos. A beágyazott típusok akkor hasznosak, ha a deklarálási típus a beágyazott típus példányait használja és hozza létre, és a beágyazott típus használata nem érhető el a nyilvános tagokban.

A beágyazott típusok egyes fejlesztők számára zavaróak, és csak akkor lehetnek nyilvánosan láthatóak, ha a láthatóságnak meggyőző oka van. A jól megtervezett kódtárakban a fejlesztőknek ritkán kell beágyazott típusokat használniuk az objektumok példányosításához vagy változók deklarálásához.

A típustagok jellemzői

A közös típusrendszer lehetővé teszi, hogy a típustagok különböző jellemzőkkel rendelkezzenek; azonban a nyelvek nem szükségesek az összes jellemző támogatásához. Az alábbi táblázat a tagok jellemzőit ismerteti.

Túlterhelés

Minden típustag egyedi aláírással rendelkezik. A metódus-aláírások a metódus nevét és egy paraméterlistát (a metódus argumentumainak sorrendjét és típusait) tartalmazzák. Egy típuson belül több azonos nevű metódus is definiálható, feltéve, hogy az aláírásuk eltér. Ha két vagy több azonos nevű metódus van definiálva, a metódus túlterheltnek minősül. Például a System.CharIsDigit metódus túlterhelt. Egy metódus egy Char. A másik módszer egy String és egy Int32.

Tagok öröklése, felülbírálása és elrejtése

A származtatott típus az alaptípus minden tagját örökli; azaz ezek a tagok a származtatott típuson vannak meghatározva, és azok számára elérhetők. Az örökölt tagok viselkedése vagy tulajdonságai kétféleképpen módosíthatók:

• A származtatott típus elrejtheti az örökölt tagokat úgy, hogy azonos aláírással definiál egy új tagot. Ez egy korábban nyilvános tag magánjellegűvé tétele vagy egy öröklött metódus új viselkedésének definiálása céljából történhet.sealed

• A származtatott típus felülbírálhat egy örökölt virtuális metódust. A felülírási módszer új definíciót ad a meghívandó metódusnak a futtatáskor használt érték típusa alapján, nem pedig a fordításkor ismert változó típusa alapján. A metódusok csak akkor bírálhatnak felül egy virtuális metódust, ha a virtuális metódus nincs megjelölve, sealed és az új metódus legalább olyan elérhető, mint a virtuális módszer.

Lásd még

• .NET API böngésző
• Common Language Runtime
• Típuskonvertálás a .NET-ben