Objektově orientované programování (C# a Visual Basic)

V rozhraní.NET Framework, jako je například Visual Basic a C#, všechny spravované jazyky poskytují úplnou podporu pro objektově orientované programování, včetně zapouzdření, dědičnost a polymorfismus.

Zapouzdření znamená, že skupinu souvisejících vlastností, metod a dalšími členy jsou považovány za jednu jednotku nebo objekt.

Dědičnost Popisuje schopnost vytvářet nové třídy na základě existující třídy.

Polymorfismus znamená, že můžete mít více tříd, které jsou zaměnitelné, i když každá třída implementuje stejné vlastnosti nebo metody různými způsoby.

Tato část popisuje následující pojmy:

• Třídy a objekty

  • Členy třídy

    Pole a vlastnosti

    Metody

    Konstruktory

    Destruktory

    Události

    Vnořené třídy

  • Modifikátory přístupu a úrovně přístupu

  • Vytvoření instance třídy

  • Statické (sdílené) tříd a členů

  • Anonymní typy

• Dědičnost

  • Přepsání členů

• Rozhraní

• Obecné typy

• Delegáti

Třídy a objekty

Podmínky Třída a objekt se někdy používají vzájemně zaměňovat, ale ve skutečnosti třídy popisují Typ objektů, zatímco objekty jsou použitelné instance tříd.Proto je volána při vytvoření objektu vytváření instance.Použití analogie matrici, třída je to plán a budovy z tento plán, podle kterého je objekt.

Chcete-li definovat třídu:

Class SampleClass
End Class

class SampleClass
{
}

Visual Basic a C# poskytují také jednoduchá verze třídy nazvané struktury které jsou užitečné, pokud potřebujete vytvořit velkou řadu objektů a proveďte není potřeba pro které spotřebovávají příliš mnoho paměti.

Chcete-li definovat strukturu:

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Další informace naleznete v následujících tématech:

• Visual Basic

  • Příkaz class (Visual Basic)

  • Výpis struktury

• C#

  • třídy (C#-Reference)

  • Struktura (C#-Reference)

Členy třídy

Každá třída může mít různé členy třídy které obsahují vlastnosti, které popisují data třídy, metody, které určují chování třídy a události, které umožňují komunikaci mezi různými třídami a objekty.

Pole a vlastnosti

Pole a vlastnosti představují informace, které obsahuje objekt.Pole jsou stejně jako proměnné, protože mohou být číst nebo nastavit přímo.

Chcete-li definovat pole:

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

Vlastnosti mají get a set postupy, které poskytují větší kontrolu, jak jsou hodnoty nastavení nebo vráceny.

I C# a Visual Basic umožňuje buď vytvořit soukromé pole k uložení hodnoty vlastnosti nebo použít takzvané automaticky implementované vlastnosti, které vytvářejí toto pole automaticky na pozadí a stanovit postupy vlastnost základní logika.

Chcete-li definovat automaticky implementovanou vlastnost:

Class SampleClass
    Public Property SampleProperty as String
End Class

class SampleClass
{
    public int SampleProperty { get; set; }
}

Pokud je třeba provést některé další operace čtení a zápisu hodnoty vlastnosti pole pro uložení hodnoty vlastnosti definovat a poskytnout základní logiku pro ukládání a načítání je:

Class Samplelass
    Private m_Sample As String
    Public Property Sample() As String
        Get
            ' Return the value stored in the field.
            Return m_Sample
        End Get
        Set(ByVal Value As String)
            ' Store the value in the field.
            m_Sample = Value
        End Set
    End Property
End Class

class SampleClass
{
    private int _sample;
    public int Sample
    {
        // Return the value stored in a field.
        get { return _sample; }
        // Store the value in the field.
        set { _sample = value; }
    }
}

Většinu vlastností existují metody a postupy, jak nastavit a získat hodnotu vlastnosti.Můžete však vytvořit vlastnosti jen pro čtení nebo jen pro zápis omezení je číst nebo upravovat.V jazyce Visual Basic můžete použít Jen pro čtení a Typu WriteOnly klíčová slova.V jazyce C#, můžete vynechat získat nebo Sada Metoda vlastnosti.Však v jazyce Visual Basic i C#, automaticky implementované vlastnosti nemůže být jen pro čtení nebo jen pro zápis.

Další informace naleznete v následujících tématech:

• Visual Basic

  • Popis vlastností

  • Příkaz GET

  • Příkaz set (Visual Basic)

  • Jen pro čtení (Visual Basic)

  • Typu WriteOnly (Visual Basic)

• C#

  • Get (C#-Reference)

  • nastavit (C#-Reference)

Metody

A Metoda je akce, kterou objekt může provádět.

[!POZNÁMKA]

V jazyce Visual Basic existují dva způsoby, jak vytvořit metodu: na Sub příkaz se používá, pokud metoda nevrací hodnotu; na Funkce příkaz se používá, pokud metoda vrátí hodnotu.

Chcete-li definovat metodu třídy:

Class SampleClass
    Public Function SampleFunc(ByVal SampleParam As String)
        ' Add code here
    End Function
End Class

class SampleClass
{
    public int sampleMethod(string sampleParam)
    {
        // Insert code here
    }
}

Třída může mít několik implementací nebo přetížení, stejné metody, která se liší v počtu parametry nebo typy parametrů.

Chcete-li přetížit metodu:

Overloads Sub Display(ByVal theChar As Char)
    ' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
    ' Add code that displays Integer data.
End Sub

public int sampleMethod(string sampleParam) {};
public int sampleMethod(int sampleParam) {}

Ve většině případů je deklarovat metodu v rámci definice třídy.Však také podporují Visual Basic a C# rozšíření metody které umožňují přidat do existující třídy mimo aktuální definice třídy metod.

Další informace naleznete v následujících tématech:

• Visual Basic

  • Příkaz funkce (Visual Basic)

  • Příkaz Sub (Visual Basic)

  • Přetížení (Visual Basic)

  • Rozšíření metody (Visual Basic)

• C#

  • Metody (Příručka programování C#)

  • Rozšíření metody (Příručka programování C#)

Konstruktory

Konstruktory jsou metody třídy, které jsou spouštěny automaticky, když je vytvořen objekt daného typu.Konstruktory inicializovat obvykle datových členů nového objektu.Konstruktor lze spustit pouze jednou, pokud je vytvořena třída.Kromě toho kódu v konstruktoru vždy spouští před jiný kód ve třídě.Můžete však vytvořit více přetížení konstruktoru stejným způsobem jako u jakékoli jiné metody.

Chcete-li definovat konstruktor pro třídu:

Class SampleClass
    Sub New(ByVal s As String)
        // Add code here.
    End Sub
End Class

public class SampleClass
{
    public SampleClass()
    {
        // Add code here
    }
}

Další informace naleznete v následujících tématech:

• Visual Basic

  • Nové Sub

  • Životnost objektu: Vytváření objektů a zničeny (Visual Basic)

• C#

  • Konstruktory (Příručka programování C#)

Destruktory

Destruktory se používají k destruct instance tříd.V rozhraní.NET Framework uvolňování automaticky spravuje přidělování a uvolňování paměti pro spravované objekty ve vaší aplikaci.Však mohou stále potřebujete destruktory vyčistit všechny nespravované prostředky, které vytvoří aplikace.Může existovat pouze jeden destruktoru třídy.

Další informace o destruktory a uvolňování paměti v rozhraní.NET Framework naleznete v tématu Uvolňování paměti.

Události

Události umožňují třídy nebo dojde k objektu upozornit ostatní třídy nebo objekty, když něco zájem.Třída, která pošle (nebo vyvolává) událost je volána aplikace Publisher a třídy, které zobrazí (nebo zpracování) události nazývají. předplatitelé.Další informace o událostech jejich jsou vyvolány a zpracování, viz Zpracování a vyvolávání událostí.

• Visual Basic

  • Chcete-li deklaraci události, použijte Výpis událostí.

  • K vyvolání události, použijte Příkaz RaiseEvent.

  • Obslužné rutiny událostí pomocí deklarativní způsobem určíte, WithEvents (Visual Basic) prohlášení a Klauzule Handles (Visual Basic) klauzule.

  • Aby bylo možné dynamicky přidat, odstranit a změnit obslužnou rutinu události, který je přidružený k události, použijte Příkaz AddHandler a Prohlášení RemoveHandler spolu s Operátor AddressOf (Visual Basic).

• C#

  • Deklarace události ve třídě, použít události (C#-Reference) klíčové slovo.

  • K vyvolání události vyvolání delegát události.

  • K odběru události, použijte += operátor; odběr událost, můžete -= operátor.

Vnořené třídy

Třídy definované v jiné třídě, se nazývá vnořené.Standardně je soukromá vnořené třídy.

Class Container
    Class Nested
    ' Add code here.
    End Class
End Class

class Container
{
    class Nested
    {
        // Add code here.
    }
}

Chcete-li vytvořit instanci vnořené třídy, použijte název třídy kontejneru následuje tečka a pak následuje název vnořené třídy:

Dim nestedInstance As Container.Nested = New Container.Nested()

Container.Nested nestedInstance = new Container.Nested()

Modifikátory přístupu a úrovně přístupu

Všechny třídy a členy tříd můžete určit, jakou úroveň přístupu poskytují další třídy s použitím Modifikátory přístupu.

K dispozici jsou následující modifikátory přístupu:

Visual Basic modifikátor	Modifikátor C#	Definice
Veřejné (Visual Basic)	veřejné	Tento typ nebo člen je přístupný další kód ve stejném sestavení nebo jiná sestavení, která na ni odkazuje.
Soukromé (Visual Basic)	soukromé	Tento typ nebo člen přístupný pouze pomocí kódu ve stejné třídě.
Chráněné (Visual Basic)	chráněné	Tento typ nebo člen přístupný pouze pomocí kódu ve stejné třídě nebo v odvozené třídě.
Přítel (Visual Basic)	vnitřní	Tento typ nebo člen je přístupný kód ve stejném sestavení, nikoli však z jiného sestavení.
Protected Friend.	protected internal	Tento typ nebo člen je přístupná jakýkoli kód ve stejném sestavení, nebo všech odvozených tříd v jiném sestavení.

Další informace naleznete v tématu Úrovně přístupu v jazyce Visual Basic a Modifikátory přístupu (Příručka programování C#).

Vytvoření instance třídy

K vytvoření objektu, je nutné vytvořit instanci třídy, nebo vytvořit instanci třídy.

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Po vytvoření instance třídy, můžete přiřadit hodnoty vlastnosti a pole instance a volat metody třídy.

' Set a property value.
sampleObject.SampleProperty = "Sample String"
' Call a method.
sampleObject.SampleMethod()

// Set a property value.
sampleObject.sampleProperty = "Sample String";
// Call a method.
sampleObject.sampleMethod();

Chcete-li přiřadit hodnoty vlastnosti během procesu vytváření instance třídy, použijte inicializátory objektů:

Dim sampleObject = New SampleClass With 
    {.FirstProperty = "A", .SecondProperty = "B"}

// Set a property value.
SampleClass sampleObject = new SampleClass 
    { FirstProperty = "A", SecondProperty = "B" };

Další informace naleznete v následujících tématech:

• Visual Basic

  • Nový operátor (Visual Basic)

  • Inicializátory objektů: Pojmenované a anonymní typy (Visual Basic)

• C#

  • nový operátor (C#-Reference)

  • Objekt a kolekce Inicializátory (Příručka programování C#)

Statické (sdílené) tříd a členů

Člen statické (sdílené v jazyce Visual Basic) třídy je vlastnost, postup nebo pole, které jsou sdíleny všechny instance třídy.

Chcete-li definovat člen statické (sdílené):

Class SampleClass
    Public Shared SampleString As String = "Sample String"
End Class

static class SampleClass
{
    public static string SampleString = "Sample String";
}

Přístup ke statickému členu (sdílené), použijte název třídy bez vytvoření objektů této třídy:

MsgBox(SampleClass.SampleString)

Console.WriteLine(SampleClass.SampleString);

Statické (sdílené) třídy v jazyce C# a moduly v jazyce Visual Basic jsou pouze statické (sdílené) členy a nelze vytvořit instanci.Statické (sdílené) členy také nelze získat přístup k nestatickému (nesdílené) vlastnosti, pole nebo metody

Další informace naleznete v následujících tématech:

• Visual Basic

  • Sdílené (Visual Basic)

  • Příkaz Module

• C#

  • statické (C#-Reference)

Anonymní typy

Anonymní typy umožňují vytvářet objekty bez psaní definice třídy datového typu.Namísto toho kompilátor vygeneruje třídu pro vás.Třídy nemá žádný název použitelné a obsahuje vlastnosti, které zadáte v deklaraci objektu.

Chcete-li vytvořit instanci anonymní typ:

' sampleObject is an instance of a simple anonymous type.
Dim sampleObject = 
    New With {Key .FirstProperty = "A", .SecondProperty = "B"}

// sampleObject is an instance of a simple anonymous type.
var sampleObject = 
    new { FirstProperty = "A", SecondProperty = "B" };

Další informace naleznete v následujících tématech:

• Visual Basic: Anonymní typy (Visual Basic)

• C#: Anonymní typy (Příručka programování C#)

Dědičnost

Dědičnost umožňuje vytvořit novou třídu, která opakovaně používá, rozšiřuje a upravuje chování, který je definován v jiné třídě.Třídy, jejíž členové jsou zděděné, nazývá Základní třída, a třídu, která dědí tyto členy, se nazývá odvozená třída.Nicméně všechny třídy v jazyce C# a Visual Basic implicitně dědí z Object Třída, která podporuje hierarchie tříd .NET a poskytuje nižší úrovně služby všem třídám.

[!POZNÁMKA]

Spravované jazyky v rozhraní.NET Framework nepodporuje vícenásobnou dědičnost, i.e. lze určit pouze jeden základní třídu odvozené třídy.

Chcete-li dědit ze základní třídy:

Class DerivedClass
    Inherits BaseClass
End Class

class DerivedClass:BaseClass{}

Ve výchozím nastavení mohou být zděděny všech tříd.Však můžete určit, zda třída nesmí být použita jako základní třída nebo vytvořit třídu, která slouží jako základní třída.

Chcete-li určit, že třídu nelze použít jako základní třídu:

NotInheritable Class SampleClass
End Class

public sealed class A { }

Chcete-li určit, zda třída slouží jako základní třída a nelze vytvořit instanci:

MustInherit Class BaseClass
End Class

public abstract class B { }

Další informace naleznete v následujících tématech:

• Visual Basic

  • Dědí prohlášení

  • Nezděditelné (Visual Basic)

  • MustInherit (Visual Basic)

• C#

  • uzavřených (C#-Reference)

  • abstraktní (C#-Reference)

Přepsání členů

Ve výchozím nastavení odvozená třída dědí všechny členy svou základní třídu.Pokud chcete změnit chování zděděný člen, je třeba ji potlačit.To znamená, že můžete definovat novou implementaci metody, vlastnosti nebo události v odvozené třídě.

Následující parametry je možné určit, jak přepsat vlastnosti a metody:

Visual Basic modifikátor	Modifikátor C#	Definice
Overridable (Visual Basic)	virtuální (C#-Reference)	Umožňuje člen třídy přepsat v odvozené třídě.
Přepíše (Visual Basic)	přepsat (C#-Reference)	Přepíše člena virtuální (overridable) definované v základní třídě.
NotOverridable (Visual Basic)	Není podporována	Zabrání přepsání dědičných třídy člena.
MustOverride (Visual Basic)	abstraktní (C#-Reference)	Vyžaduje, aby člen třídy přepsat v odvozené třídě.
Stíny (Visual Basic)	Modifikátor nové (C#-Reference)	Člen je zděděna ze základní třídy kůže

Rozhraní

Rozhraní, stejně jako třídy, definují sadu vlastností, metod a událostí.Ale na rozdíl od tříd, rozhraní neposkytují implementace.Jsou implementované třídami a definovány jako samostatné subjekty ze třídy.Rozhraní představuje smlouvu, v tom, že třída, která implementuje rozhraní musí implementovat všechny aspekty tohoto rozhraní, přesně tak, jak je definován.

Chcete-li definovat rozhraní:

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

interface ISampleInterface
{
    void doSomething();
}

Chcete-li implementovat rozhraní ve třídě:

Class SampleClass
    Implements ISampleInterface
    Sub doSomething
        ' Method implementation.
    End Sub
End Class

class SampleClass : ISampleInterface
{
    void ISampleInterface.SampleMethod()
    {
        // Method implementation.
    }
}

Další informace naleznete v následujících tématech:

• Visual Basic

  • Rozhraní (Visual Basic)

  • Rozhraní prohlášení (Visual Basic)

  • Implementuje prohlášení

• C#

  • Rozhraní (Příručka programování C#)

  • rozhraní (C#-Reference)

Obecné typy

Třídy, struktury, rozhraní a metod v rozhraní.NET Framework můžete parametry typu které definují typy objektů, které lze uložit nebo použít.Nejběžnějším příkladem generik je kolekce, kde můžete zadat typ objektů v kolekci.

Chcete-li definovat obecná třída:

Class SampleGeneric(Of T)
    Public Field As T
End Class

Public class SampleGeneric<T> 
{
    public T Field;
}

Chcete-li vytvořit instanci obecné třídy:

Dim sampleObject As New SampleGeneric(Of String)
sampleObject.Field = "Sample string"

SampleGeneric<string> sampleObject = new SampleGeneric<string>();
sampleObject.Field = "Sample string";

Další informace naleznete v následujících tématech:

• Obecné typy v rozhraní .NET Framework

• Obecné typy jazyka Visual Basic (Visual Basic)

• Generics (Příručka programování C#)

Delegáti

A Delegát je typ, který definuje podpis metody můžete poskytnout odkaz na jakoukoli metodu podpisem kompatibilní.Můžete vyvolat (nebo volání) metody prostřednictvím delegáta.Delegáti se používají metody předat argumenty jiné metody.

[!POZNÁMKA]

Obslužné rutiny události nejsou nic jiného než metody, které jsou vyvolány prostřednictvím delegátů.Další informace o použití delegátů ve zpracování událostí naleznete v tématu Události a Delegáti.

Chcete-li vytvořit delegát:

Delegate Sub SampleDelegate(ByVal str As String)

public delegate void SampleDelegate(string str);

Chcete-li vytvořit odkaz na metodu, která odpovídá podpis zadaný delegát:

Class SampleClass
    ' Method that matches the SampleDelegate signature.
    Sub SampleSub(ByVal str As String)
        ' Add code here.
    End Sub
    ' Method that instantiates the delegate.
    Sub SampleDelegateSub()
        Dim sd As SampleDelegate = AddressOf SampleSub
        sd("Sample string")
    End Sub
End Class

class SampleClass
{
    // Method that matches the SampleDelegate signature.
    public static void sampleMethod(string message)
    {
        // Add code here.
    }
    // Method that instantiates the delegate.
    void SampleDelegate()
    {
        SampleDelegate sd = sampleMethod;
        sd("Sample string");
    }
}

Další informace naleznete v následujících tématech:

• Visual Basic

  • Delegáti (Visual Basic)

  • Delegát prohlášení

  • Operátor AddressOf (Visual Basic)

• C#

  • Delegáti (Příručka programování C#)

  • Delegát (C#-Reference)

Viz také

Koncepty

Příručka programování C#

Další zdroje

Příručka programování v jazyce Visual Basic