Členové

Členy objektu class jsou buď statické členy , nebo členy instance. Statické členy patří do tříd a členy instance patří k objektům (instancím tříd).

Následující seznam obsahuje přehled typů členů, které může třída obsahovat.

• Konstanty: Konstantní hodnoty přidružené ke třídě
• Pole: Proměnné, které jsou přidruženy k třídě
• Metody: Akce, které může třída provádět
• Vlastnosti: Akce spojené se čtením a zápisem pojmenovaných vlastností třídy
• Indexery: Akce přidružené k indexování instancí třídy, jako je pole
• Události: Oznámení, která mohou být generována třídou
• Operátory: Převody a operátory výrazů podporované třídou
• Konstruktory: Akce potřebné k inicializaci instancí třídy nebo samotné třídy
• Finalizační metody: Akce provedené před trvalým zahozením instancí třídy
• Typy: Vnořené typy deklarované třídou

Každý člen třídy má přidruženou přístupnost, která řídí oblasti textu programu, které mají přístup k členu. Existuje šest možných forem přístupnosti. Níže jsou shrnuté modifikátory přístupu.

• public: Přístup není omezený.
• private: Přístup je omezen na tuto třídu.
• protected: Přístup je omezen na tuto třídu nebo třídy odvozené z této třídy.
• internal: Přístup je omezen na aktuální sestavení (.exe nebo .dll).
• protected internal: Přístup je omezen na tuto třídu, třídy odvozené z této třídy nebo třídy v rámci stejného sestavení.
• private protected: Přístup je omezen na tuto třídu nebo třídy odvozené z tohoto typu v rámci stejného sestavení.

Pole je proměnná, která je přidružená ke třídě nebo instanci třídy.

Pole deklarované se statickým modifikátorem definuje statické pole. Statické pole identifikuje přesně jedno umístění úložiště. Bez ohledu na to, kolik instancí třídy je vytvořeno, existuje vždy jen jedna kopie statického pole.

Pole deklarované bez statického modifikátoru definuje pole instance. Každá instance třídy obsahuje samostatnou kopii všech polí instance této třídy.

V následujícím příkladu Color má každá instance třídy samostatnou kopii Rpolí , Ga B instance, ale existuje pouze jedna kopie statických Blackpolí , White, Red, Greena Blue :

public class Color
{
    public static readonly Color Black = new(0, 0, 0);
    public static readonly Color White = new(255, 255, 255);
    public static readonly Color Red = new(255, 0, 0);
    public static readonly Color Green = new(0, 255, 0);
    public static readonly Color Blue = new(0, 0, 255);
    
    public byte R;
    public byte G;
    public byte B;    public Color(byte r, byte g, byte b)
    {
        R = r;
        G = g;
        B = b;
    }
}

Jak je znázorněno v předchozím příkladu, pole jen pro čtení mohou být deklarována pomocí modifikátoru readonly . Přiřazení k poli jen pro čtení může probíhat pouze jako součást deklarace pole nebo v konstruktoru ve stejné třídě.

Metoda je člen, který implementuje výpočet nebo akci, která může být provedena objektem nebo třídou. Statické metody jsou přístupné prostřednictvím třídy. K metodám instance se přistupuje prostřednictvím instancí třídy.

Metody mohou mít seznam parametrů, které představují hodnoty nebo odkazy na proměnné předávané metodě. Metody mají návratový typ, který určuje typ hodnoty vypočítané a vrácené metodou. Návratový typ metody je void ten, který nevrací hodnotu.

Podobně jako typy mohou mít i metody sadu parametrů typu, pro které musí být zadány argumenty typu při zavolání metody. Na rozdíl od typů mohou být argumenty typu často odvozeny z argumentů volání metody a nemusí být explicitně uvedeny.

Podpis metody musí být jedinečný ve třídě, ve které je metoda deklarována. Podpis metody se skládá z názvu metody, počtu parametrů typu a čísla, modifikátorů a typů jejích parametrů. Podpis metody neobsahuje návratový typ.

Pokud je tělo metody jedním výrazem, lze metodu definovat pomocí kompaktního formátu výrazu, jak je znázorněno v následujícím příkladu:

 "This is an object";
" style="box-sizing: inherit; outline-color: inherit; font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace; font-size: 1em; direction: ltr; border: 0px; padding: 0px; line-height: 1.3571; display: block; position: relative;">public override string ToString() => "This is an object";

Parametry se používají k předávání hodnot nebo odkazů na proměnné metodám. Parametry metody získávají své skutečné hodnoty z argumentů , které jsou zadány při vyvolání metody. Existují čtyři druhy parametrů: parametry hodnot, referenční parametry, výstupní parametry a pole parametrů.

Parametr hodnoty se používá pro předávání vstupních argumentů. Parametr hodnoty odpovídá místní proměnné, která získá počáteční hodnotu z argumentu, který byl předán pro parametr. Úpravy parametru hodnoty nemají vliv na argument, který byl předán parametru.

Parametry hodnoty mohou být volitelné zadáním výchozí hodnoty, aby bylo možné vynechat odpovídající argumenty.

Parametr odkazu se používá pro předávání argumentů podle odkazu. Argument předaný pro parametr odkazu musí být proměnná s určitou hodnotou. Během provádění metody představuje parametr reference stejné umístění úložiště jako proměnná argumentu. Referenční parametr je deklarován pomocí modifikátoru ref . Následující příklad ukazuje použití ref parametrů.

static void Swap(ref int x, ref int y)
{
    int temp = x;
    x = y;
    y = temp;
}public static void SwapExample()
{
    int i = 1, j = 2;
    Swap(ref i, ref j);
    Console.WriteLine($"{i} {j}");    // "2 1"
}

Výstupní parametr se používá pro předávání argumentů podle odkazu. Podobá se referenčnímu parametru s tím rozdílem, že nevyžaduje explicitní přiřazení hodnoty k argumentu poskytnutému volajícím. Výstupní parametr je deklarován pomocí modifikátoru out . Následující příklad ukazuje použití out parametrů.

static void Divide(int x, int y, out int quotient, out int remainder)
{
    quotient = x / y;
    remainder = x % y;
}public static void OutUsage()
{
    Divide(10, 3, out int quo, out int rem);
    Console.WriteLine($"{quo} {rem}");	// "3 1"
}

Pole parametrů umožňuje předat metodě proměnný počet argumentů. Pole parametrů je deklarováno pomocí modifikátoru params . Pole parametrů může být pouze posledním parametrem metody a typ pole parametrů musí být jednorozměrný typ pole. Metody WriteSystem.Console a WriteLine třídy jsou dobrými příklady použití pole parametrů. Jsou deklarovány následujícím způsobem.

public class Console
{
    public static void Write(string fmt, params object[] args) { }
    public static void WriteLine(string fmt, params object[] args) { }
    // ...
}

V metodě, která používá pole parametrů, se pole parametrů chová přesně jako běžný parametr typu pole. Při vyvolání metody s polem parametrů je však možné předat buď jeden argument typu pole parametru, nebo libovolný počet argumentů typu prvku pole parametru. V druhém případě se instance pole automaticky vytvoří a inicializuje pomocí zadaných argumentů. Tento příklad

int x, y, z;
x = 3;
y = 4;
z = 5;
Console.WriteLine("x={0} y={1} z={2}", x, y, z);

je ekvivalentem psaní následujícího textu.

int x = 3, y = 4, z = 5;string s = "x={0} y={1} z={2}";
object[] args = new object[3];
args[0] = x;
args[1] = y;
args[2] = z;
Console.WriteLine(s, args);

Tělo metody určuje příkazy, které se mají provést při vyvolání metody.

Tělo metody může deklarovat proměnné, které jsou specifické pro vyvolání metody. Takové proměnné se nazývají místní proměnné. Deklarace místní proměnné určuje název typu, název proměnné a případně počáteční hodnotu. Následující příklad deklaruje místní proměnnou i s počáteční hodnotou nula a místní proměnnou j bez počáteční hodnoty.

class Squares
{
    public static void WriteSquares()
    {
        int i = 0;
        int j;
        while (i < 10)
        {
            j = i * i;
            Console.WriteLine($"{i} x {i} = {j}");
            i++;
        }
    }
}

Jazyk C# vyžaduje, aby před získáním její hodnoty byla jednoznačně přiřazena místní proměnná. Pokud například deklarace předchozí i neobsahuje počáteční hodnotu, kompilátor by ohlásil chybu pro pozdější použití nástroje i , protože i by v těchto bodech v programu nebyla jednoznačně přiřazena.

Metoda může pomocí return příkazů vrátit řízení volajícímu. V metodě vracející voidpříkazy return nemůžou zadat výraz. V metodě vracející non-void return musí příkazy obsahovat výraz, který vypočítá návratovou hodnotu.