Programmation orientée objet (C# et Visual Basic)

Tous les langages managés dans le.NET Framework, tels que Visual Basic et C#, fournissent la prise en charge complète pour la programmation orientée objet, y compris d'encapsulation, héritage et polymorphisme.

Encapsulation signifie qu'un groupe de propriétés connexes, les méthodes et les autres membres est traité comme une seule unité ou un objet.

Héritage Décrit la possibilité de créer de nouvelles classes basées sur une classe existante.

Polymorphisme signifie que vous pouvez avoir plusieurs classes qui peuvent être utilisés indifféremment, même si chacune des classes implémente les mêmes propriétés et méthodes de différentes manières.

Cette section décrit les concepts suivants :

• Classes et objets

  • Membres de classe

    Champs et propriétés

    Méthodes

    Constructeurs

    Destructeurs

    Événements

    Classes imbriquées

  • Modificateurs d'accès et les niveaux d'accès

  • L'instanciation de Classes

  • Statique (partagée) Classes et membres

  • Types anonymes

• Héritage

  • Substituer des membres

• Interfaces

• Génériques

• Délégués

Classes et objets

Les termes du contrat classe et objet sont parfois utilisés indifféremment, mais en fait, les classes décrivent la type d'objets, tandis que les objets sont utilisables instances des classes.Ainsi, l'acte de la création d'un objet est appelée lors de l'instanciation.À l'aide de l'analogie avec le plan, une classe est un plan et un objet est un bâtiment construit à partir de ce plan.

Pour définir une classe :

Class SampleClass
End Class

class SampleClass
{
}

Visual Basic et C# fournissent également une version basique de classes appelée structures qui sont utiles lorsque vous devez créer un grand tableau d'objets et faire que vous voulez pas utiliser trop de mémoire pour cette.

Pour définir une structure :

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Pour plus d'informations, voir :

• Visual Basic

  • Class, instruction (Visual Basic)

  • Structure, instruction

• C#

  • class (référence C#)

  • struct (Référence C#)

Membres de classe

Chaque classe peut avoir différents membres de classe qui incluent des propriétés qui décrivent les données de la classe, les méthodes qui définissent le comportement de la classe et les événements qui assurent la communication entre les différents objets et classes.

Champs et propriétés

Champs et les propriétés représentent des informations qui contient un objet.Les champs sont similaires aux variables car ils peuvent lire ou définir directement.

Pour définir un champ :

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

Propriétés possèdent get et définir des procédures qui permettent de mieux contrôler sur comment les valeurs sont définies ou retournées.

C# et Visual Basic permettent de créer un champ privé pour stocker la valeur de propriété ou d'utiliser ce que l'on appelle propriétés implémentées automatiquement qui créent ce champ automatiquement en arrière-plan et de fournissent la logique de base pour les procédures de propriété.

Pour définir une propriété implémentée automatiquement :

Class SampleClass
    Public Property SampleProperty as String
End Class

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

Si vous avez besoin effectuer des opérations supplémentaires pour lire et écrire la valeur de propriété, définissez un champ pour stocker la valeur de propriété et fournir la logique de base pour stocker et récupérer :

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

La plupart des propriétés ont des méthodes ou des procédures pour définir et obtenir la valeur de propriété.Toutefois, vous pouvez créer des propriétés en lecture seule ou en écriture seule pour empêcher qu'elles soient modifiées ou lues.Dans Visual Basic, vous pouvez utiliser En lecture seule et WriteOnly mots clés.En C#, vous pouvez omettre le Get ou ensemble méthode de propriété.Toutefois, dans Visual Basic et C#, les propriétés implémentées automatiquement ne peut pas être en lecture seule ou en écriture seule.

Pour plus d'informations, voir :

• Visual Basic

  • Property, instruction

  • Get, instruction

  • Set, instruction (Visual Basic)

  • ReadOnly (Visual Basic)

  • WriteOnly (Visual Basic)

• C#

  • get (référence C#)

  • set (référence C#)

Méthodes

A méthode est une action qui peut effectuer un objet.

[!REMARQUE]

Dans Visual Basic, il existe deux façons de créer une méthode : le Sub instruction est utilisée si la méthode ne retourne pas de valeur ; le Fonction instruction est utilisée si une méthode retourne une valeur.

Pour définir une méthode d'une classe :

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

Une classe peut avoir plusieurs implémentations, ou surcharges, de la même méthode qui diffèrent dans le nombre de paramètres ou les types de paramètres.

Pour surcharger une méthode :

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) {}

Dans la plupart des cas, vous déclarez une méthode dans une définition de classe.Toutefois, Visual Basic et C# également prendre en charge méthodes d'extension qui permettent d'ajouter des méthodes à une classe existante en dehors de la définition réelle de la classe.

Pour plus d'informations, voir :

• Visual Basic

  • Function, instruction (Visual Basic)

  • Sub, instruction (Visual Basic)

  • Overloads (Visual Basic)

  • Méthodes d'extension (Visual Basic)

• C#

  • Méthodes (guide de programmation C#)

  • Méthodes d'extension (Guide de programmation C#)

Constructeurs

Les constructeurs sont des méthodes de classe qui sont exécutées automatiquement lors de la création d'un objet d'un type donné.Les constructeurs initialisent habituellement les membres de données du nouvel objet.Un constructeur peut s'exécuter qu'une seule fois lors de la création d'une classe.En outre, le code dans le constructeur s'exécute toujours avant tout autre code dans une classe.Toutefois, vous pouvez créer plusieurs surcharges de constructeur de la même manière que pour toute autre méthode.

Pour définir un constructeur pour une classe :

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

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

Pour plus d'informations, voir :

• Visual Basic

  • Sub New

  • Durée de vie d'un objet : création et destruction des objets (Visual Basic)

• C#

  • Constructeurs (guide de programmation C#)

Destructeurs

Les destructeurs sont utilisés pour détruire des instances de classes.Dans le.NET Framework, le garbage collector gère automatiquement l'allocation et la libération de mémoire pour les objets gérés dans votre application.Toutefois, vous deviez destructeurs pour nettoyer les ressources non managées créées par votre application.Il peut y avoir qu'un seul destructeur pour une classe.

Pour plus d'informations sur les destructeurs et garbage collection dans le.NET Framework, consultez Garbage Collection.

Événements

Les événements permettent à une classe ou objet de notifier d'autres classes ou objets lorsqu'une situation intéressante se produit.La classe qui envoie (ou déclenche) l'événement est appelée le Publisher et les classes qui reçoivent (ou gèrent) l'événement sont appelées abonnés.Pour plus d'informations sur les événements, comment ils sont déclenchés et leur gestion, consultez Gestion et déclenchement d'événements.

• Visual Basic

  • Pour déclarer des événements, utilisez le Event, instruction.

  • Pour déclencher des événements, utilisez le RaiseEvent, instruction.

  • Pour spécifier des gestionnaires d'événements à l'aide d'une manière déclarative, utilisez la WithEvents (Visual Basic) instruction et le Handles, clause (Visual Basic) clause.

  • Pour pouvoir ajouter, supprimer et modifier le Gestionnaire d'événements associé à un événement de façon dynamique, utilisez la AddHandler, instruction et RemoveHandler, instruction conjointement avec le Opérateur AddressOf (Visual Basic).

• C#

  • Pour déclarer un événement dans une classe, utilisez le event (référence C#) mot clé.

  • Pour déclencher un événement, appelez le délégué d'événement.

  • Pour vous abonner à un événement, utilisez la += opérateur ; Pour annuler l'abonnement à un événement, utilisez la -= opérateur.

Classes imbriquées

Une classe définie dans une autre classe est appelée. imbriqués.Par défaut, la classe imbriquée est privée.

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

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

Pour créer une instance de la classe imbriquée, utilisez le nom de la classe de conteneur suivi par le point et ensuite suivi par le nom de la classe imbriquée :

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

Container.Nested nestedInstance = new Container.Nested()

Modificateurs d'accès et les niveaux d'accès

Toutes les classes et membres de classe peuvent spécifier le niveau d'accès fourni aux autres classes à l'aide de modificateurs d'accès.

Les modificateurs d'accès suivantes sont disponibles :

Modificateur de Visual Basic	Modificateur C#	Définition
Public (Visual Basic)	public	Le type ou le membre accessible par tout autre code dans le même assembly ou un autre assembly qui y fait référence.
Private (Visual Basic)	privé	Le type ou le membre accessible uniquement par le code dans la même classe.
Protected (Visual Basic)	protégé	Le type ou le membre accessible uniquement par le code dans la même classe ou dans une classe dérivée.
Friend (Visual Basic)	interne	Le type ou le membre accessibles par tout code dans le même assembly, mais pas d'un autre assembly.
Protected Friend	protected internal	Le type ou le membre est accessible par n'importe quel code dans le même assembly, ou par toute classe dérivée dans un autre assembly.

Pour plus d'informations, consultez Niveaux d'accès dans Visual Basic et Modificateurs d'accès (Guide de programmation C#).

L'instanciation de Classes

Pour créer un objet, vous devez instancier une classe, ou de créer une instance de classe.

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Après l'instanciation d'une classe, vous pouvez affecter des valeurs aux propriétés et les champs de l'instance et appeler des méthodes de classe.

' 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();

Pour affecter des valeurs aux propriétés au cours du processus d'instanciation de classe, utilisez des initialiseurs d'objet :

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

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

Pour plus d'informations, voir :

• Visual Basic

  • New, opérateur (Visual Basic)

  • Initialiseurs d'objets : types nommés et anonymes (Visual Basic)

• C#

  • new, opérateur (référence C#)

  • Initialiseurs d'objets et de collection (Guide de programmation C#)

Statique (partagée) Classes et membres

Un membre static (shared dans Visual Basic) de la classe est une propriété, une procédure ou un champ qui est partagée par toutes les instances d'une classe.

Pour définir un membre statique (partagé) :

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

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

Pour accéder au membre statique (partagé), utilisez le nom de la classe sans créer d'objet de cette classe :

MsgBox(SampleClass.SampleString)

Console.WriteLine(SampleClass.SampleString);

Les classes static (shared) dans C# et les modules Visual Basic ont des membres statiques (partagés) uniquement et ne peut pas être instanciées.Membres statiques (partagés) ne peut pas également accéder aux champs, les propriétés non statiques (non partagée) ou des méthodes

Pour plus d'informations, voir :

• Visual Basic

  • Shared (Visual Basic)

  • Module, instruction

• C#

  • static (référence C#)

Types anonymes

Les types anonymes permettent de créer des objets sans écrire de définition de classe pour le type de données.En revanche, le compilateur génère une classe pour vous.La classe n'a aucun nom utilisable et contient les propriétés que vous spécifiez dans la déclaration de l'objet.

Pour créer une instance d'un type anonyme :

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

Pour plus d'informations, voir :

• Visual Basic : Types anonymes (Visual Basic)

• C# : Types anonymes (Guide de programmation C#)

Héritage

L'héritage vous permet de créer une nouvelle classe qui réutilise, étend et modifie le comportement est défini dans une autre classe.La classe dont les membres sont hérités est appelée le classe de base, et la classe qui hérite de ces membres est appelée le classe dérivée.Toutefois, toutes les classes dans C# et Visual Basic héritent implicitement de la Object classe qui prend en charge la hiérarchie de classes .NET et fournit des services de bas niveau à toutes les classes.

[!REMARQUE]

Langages managés dans le.NET Framework ne prennent pas en charge l'héritage multiple, je.e. vous pouvez spécifier qu'une seule classe de base pour une classe dérivée.

Pour hériter d'une classe de base :

Class DerivedClass
    Inherits BaseClass
End Class

class DerivedClass:BaseClass{}

Par défaut, toutes les classes peuvent être héritées.Toutefois, vous pouvez spécifier si une classe ne doit pas être utilisée comme classe de base, ou créer une classe qui peut être utilisée comme une classe de base.

Pour spécifier qu'une classe ne peut pas être utilisée comme classe de base :

NotInheritable Class SampleClass
End Class

public sealed class A { }

Pour spécifier qu'une classe peut être utilisée comme une classe de base et ne peut pas être instanciée :

MustInherit Class BaseClass
End Class

public abstract class B { }

Pour plus d'informations, voir :

• Visual Basic

  • Inherits, instruction

  • NotInheritable (Visual Basic)

  • MustInherit (Visual Basic)

• C#

  • sealed (référence C#)

  • abstract (référence C#)

Substituer des membres

Par défaut, une classe dérivée hérite de tous les membres de sa classe de base.Si vous souhaitez modifier le comportement du membre hérité, vous devez le substituer.Autrement dit, vous pouvez définir une nouvelle implémentation de la méthode, la propriété ou l'événement dans la classe dérivée.

Les modificateurs suivants sont utilisés pour contrôler la façon dont les propriétés et méthodes sont substituées :

Modificateur de Visual Basic	Modificateur C#	Définition
Overridable (Visual Basic)	virtual (référence C#)	Permet à un membre de classe à être substituée dans une classe dérivée.
Overrides (Visual Basic)	override (référence C#)	Substitue un membre virtuel (substituable), défini dans la classe de base.
NotOverridable (Visual Basic)	Non pris en charge	Empêche un membre de la substitution dans une classe qui hérite.
MustOverride (Visual Basic)	abstract (référence C#)	Requiert qu'un membre de classe à être substituée dans la classe dérivée.
Shadows (Visual Basic)	new, modificateur (référence C#)	Masque un membre hérité d'une classe de base

Interfaces

Comme les classes, les interfaces définissent un ensemble de propriétés, méthodes et événements.Mais contrairement aux classes, interfaces ne fournissent pas d'implémentation.Ils sont implémentés par les classes et définis en tant qu'entités distinctes des classes.Une interface représente un contrat, dans la mesure où une classe qui implémente une interface doit implémenter tous les aspects de cette interface exactement telle qu'elle est définie.

Pour définir une interface :

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

interface ISampleInterface
{
    void doSomething();
}

Pour implémenter une interface dans une classe :

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

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

Pour plus d'informations, voir :

• Visual Basic

  • Interfaces (Visual Basic)

  • Interface, instruction (Visual Basic)

  • Implements, instruction

• C#

  • Interfaces (Guide de programmation C#)

  • interface (référence C#)

Génériques

Classes, structures, interfaces et méthodes dans le.NET Framework peut paramètres de type qui définissent des types d'objets qu'ils peuvent stocker ou utiliser.L'exemple le plus courant des génériques est une collection, où vous pouvez spécifier le type des objets qui seront stockées dans une collection.

Pour définir une classe générique :

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

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

Pour créer une instance d'une classe générique :

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

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

Pour plus d'informations, voir :

• Génériques dans le .NET Framework

• Types génériques en Visual Basic (Visual Basic)

• Génériques (guide de programmation C#)

Délégués

A délégué est un type qui définit une signature de méthode et peut fournir une référence à n'importe quelle méthode avec une signature compatible.Vous pouvez appeler (ou appeler) la méthode par le biais du délégué.Les délégués sont utilisés pour passer des méthodes en tant qu'arguments à d'autres méthodes.

[!REMARQUE]

Gestionnaires d'événements sont tout simplement des méthodes qui sont appelées par le biais de délégués.Pour plus d'informations sur l'utilisation de délégués dans la gestion des événements, consultez Événements et délégués.

Pour créer un délégué :

Delegate Sub SampleDelegate(ByVal str As String)

public delegate void SampleDelegate(string str);

Pour créer une référence à une méthode qui correspond à la signature spécifiée par le délégué :

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

Pour plus d'informations, voir :

• Visual Basic

  • Délégués (Visual Basic)

  • Delegate, instruction

  • Opérateur AddressOf (Visual Basic)

• C#

  • Délégués (guide de programmation C#)

  • delegate (référence C#)

Voir aussi

Concepts

Guide de programmation C#

Autres ressources

Guide de programmation Visual Basic