Share via

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

  • Article

Tous les langages managés dans le .NET Framework, tels que Visual Basic et C#, fournissent une prise en charge totale de la programmation orientée objet notamment l'encapsulation, l'héritage et le polymorphisme.

L'encapsulation signifie qu'un groupe de propriétés, méthodes et autres membres liés est traité comme une unité ou un objet unique.

L'héritage décrit la possibilité de créer de nouvelles classes en fonction d'une classe existante.

Le polymorphisme signifie que plusieurs classes peuvent être utilisées de manière interchangeable, même si chacune des classes implémente les mêmes propriétés et méthodes de manière différente.

Cette section décrit les concepts suivants :

  • Classes et objets

    • Membres de classe

      Propriétés et champs

      Méthodes

      Constructeurs

      Destructeurs

      Événements

      Classes imbriquées

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

    • Instanciation de classes

    • Classes et membres statiques (partagés)

    • Types anonymes

  • Héritage

    • Substitution de membres

  • Interfaces

  • Génériques

  • Délégués

Classes et objets

Les termes classe et objet sont parfois employés indifféremment, mais en réalité, les classes décrivent le type des objets, alors que ces derniers sont des instances utilisables de classes. Ainsi, l'opération de création d'un objet est appelée instanciation. Si l'on reprend l'analogie avec un plan de construction, 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 tous deux une version basique de classes appelée structures qui sont utiles lorsque vous avez besoin de créer un grand tableau d'objets et que vous ne souhaitez pas utiliser trop de mémoire pour cette opération.

Pour définir une structure :

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Pour plus d'informations, consultez :

Membres de classe

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

Propriétés et champs

Les propriétés et les champs sont des informations contenues dans un objet. Les champs sont similaires aux variables, car ils peuvent être lus ou définis directement.

Pour définir un champ :

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

Les propriétés comportent des procédures Get et Set qui apportent davantage de contrôle sur le mode de définition ou de retour des valeurs.

C# et Visual Basic vous permettent tous deux de créer un champ privé pour le stockage de la valeur de propriété ou d'utiliser des propriétés implémentées automatiquement qui créent ce champ de façon automatique en arrière-plan et fournissent la logique de base des 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 devez exécuter des opérations supplémentaires pour la lecture et l'écriture de la valeur de propriété, définissez un champ pour le stockage de la valeur de propriété et fournissez la logique de base pour son stockage et son extraction :

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 disposent de méthodes ou de procédures destinées à la fois à 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. En Visual Basic, vous pouvez utiliser les mots clés ReadOnly et WriteOnly. En C#, vous pouvez omettre la méthode de propriété get ou set. Toutefois, en Visual Basic comme en C#, les propriétés implémentées automatiquement ne peuvent pas être en lecture seule ni en écriture seule.

Pour plus d'informations, consultez :

Méthodes

Une méthode est une action que peut effectuer un objet.

Notes

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

Pour définir une méthode de 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 du point de vue du nombre de paramètres ou des 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# prennent tous deux également en charge des méthodes d'extension qui vous permettent d'ajouter des méthodes à une classe existante à l'extérieur de la définition réelle de la classe.

Pour plus d'informations, consultez :

Constructeurs

Les constructeurs sont des méthodes de classe qui s'exécutent automatiquement lorsqu'un objet d'un type donné est créé. Les constructeurs initialisent habituellement les données membres du nouvel objet. Un constructeur ne peut s'exécuter qu'une seule fois lorsqu'une classe est créée. En outre, le code figurant 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 façon que vous le faites 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, consultez :

Destructeurs

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

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

Événements

Les événements permettent à une classe ou un 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 éditeur 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, leur déclenchement et leur gestion, consultez Gestion et déclenchement d'événements.

Classes imbriquées

Une classe définie à l'intérieur d'une autre classe est dite imbriquée. Par défaut, une 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 d'un point, puis du 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 niveaux d'accès

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

Les modificateurs d'accès suivants sont disponibles :

Modificateur Visual Basic

Modificateur C#

Définition

Public (Visual Basic)

public

Tout autre code du même assembly ou d'un autre assembly qui y fait référence peut accéder au type ou au membre.

Private (Visual Basic)

private

Seul le code de la même classe peut accéder au type ou au membre.

Protected (Visual Basic)

protected

Seul le code de la même classe ou d'une classe dérivée peut accéder au type ou au membre.

Friend (Visual Basic)

internal

Tout code du même assembly, mais pas d'un autre assembly, peut accéder au type ou au membre.

Protected Friend

protected internal

Tout code du même assembly ou toute classe dérivée dans un autre assembly peut accéder au type ou au membre.

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

Instanciation de classes

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

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Après avoir instancié une classe, vous pouvez assigner des valeurs aux propriétés et 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 assigner des valeurs aux propriétés pendant le processus d'instanciation de la classe, utilisez des initialiseurs d'objets :

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, consultez :

Classes et membres statiques (partagés)

Un membre statique (partagé en Visual Basic) de la classe est une propriété, une procédure ou un champ 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 statiques (partagées) en C# et les modules en Visual Basic comportent des membres statiques (partagés) uniquement et ne peuvent pas être instanciés. Les membres statiques (partagés) ne peuvent pas non plus accéder aux propriétés, champs ou méthodes non statiques (non partagés).

Pour plus d'informations, consultez :

Types anonymes

Les types anonymes vous permettent de créer des objets sans écrire de définition de classe pour le type de données. À la place, le compilateur se charge de générer une classe. La classe ne possède pas de nom utilisable et contient les propriétés que vous spécifiez lors de la déclaration de l'objet.

Pour créer une instance de 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, consultez :

Héritage

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

Notes

Les langages managés dans .NET Framework ne prennent pas en charge l'héritage multiple, c'est-à-dire que vous ne 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 uniquement comme 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 uniquement comme classe de base et ne peut pas être instanciée :

MustInherit Class BaseClass
End Class

public abstract class B { }

Pour plus d'informations, consultez :

Substitution de 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, de la propriété ou de 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 les méthodes sont substituées :

Modificateur Visual Basic

Modificateur C#

Définition

Overridable (Visual Basic)

virtual (référence C#)

Autorise la substitution d'un membre de classe 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 d'être substitué dans une classe qui hérite.

MustOverride (Visual Basic)

abstract (référence C#)

Requiert qu'un membre de classe soit substitué 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

Tout comme les classes, les interfaces définissent un ensemble de propriétés, méthodes et événements. Cependant, contrairement aux classes, les interfaces n'assurent pas l'implémentation. Elles sont implémentées par les classes et définies en tant qu'entités distinctes des classes. Une interface représente un contrat, dans le sens où une classe qui implémente une interface doit implémenter tous les aspects de cette interface exactement telle qu'elle a été 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, consultez :

Génériques

Les classes, structures, interfaces et méthodes dans le .NET Framework peuvent typer des paramètres définissant des types d'objets qu'elles peuvent stocker ou utiliser. L'exemple le plus commun de génériques est une collection dans laquelle vous pouvez spécifier le type d'objets à stocker 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 de 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, consultez :

Délégués

Un délégué est un type qui définit une signature de méthode et peut fournir une référence à toute méthode avec une signature compatible. Vous pouvez appeler la méthode par le biais du délégué. Les délégués sont utilisés pour passer des méthodes comme arguments à d'autres méthodes.

Notes

Les gestionnaires d'événements sont tout simplement des méthodes 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, consultez :

Voir aussi

Concepts

Guide de programmation C#

Autres ressources

Guide de programmation Visual Basic