Remplacement en C#

La substitution en C# est la réimplémentation d'une méthode de classe de base dans une classe dérivée. En cela, la méthode de la classe de base est remplacée dans la classe enfant. La méthode de classe dérivée a le même nom et la même signature que la méthode de classe de base. Le remplacement est utile pour obtenir le polymorphisme d'exécution.

Quelques mots-clés sont utilisés dans le remplacement de méthode.

1. Virtuel – Ce mot-clé est utilisé avec une classe de base, ce qui signifie que la méthode d'une classe de base peut être remplacée.

public virtual void Method()
{
// implementation
}

2. Override – Ce mot-clé est utilisé avec une classe dérivée, ce qui signifie que la classe dérivée remplace une méthode d'une classe de base.

public override void Method()
{
// implementation
}

3. Base – Ce mot-clé est utilisé dans une classe dérivée pour appeler la méthode de la classe de base.

public override void Method()
{
base.Method();
// implementation
}

Comment fonctionne la substitution en C# ?

Vous trouverez ci-dessous un exemple de la façon dont nous pouvons implémenter la substitution en C#.

class Parent
{
public virtual void Demo()  // base class
{
Console.WriteLine(“This is parent”);
}
}
class Child: Parent
{
public override void Demo()  // derived class
{
Console.WriteLine(“This is child”);
}
}

Dans l'exemple ci-dessus, il y a deux classes, l'une est une classe de base ou une classe parent et l'autre est une classe dérivée ou nous pouvons dire une classe enfant. Une méthode de classe de base est dérivée dans la classe enfant. En cela, la méthode d'un parent est virtuelle, ce qui signifie qu'elle peut être remplacée par la classe enfant. Le remplacement chez un enfant signifie que cette méthode est la même que la méthode de la classe parent avec la même signature de méthode.

Types de remplacement en C#

Vous trouverez ci-dessous les exemples qui montrent le remplacement de divers mots-clés.

Exemple 1 – Sans mots-clés virtuels et de remplacement

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird   // base class
{
public void fly()  // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public new void fly()  // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Bird b = new Peacock();
b.fly();
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, aucun mot-clé n'est utilisé dans les deux bases ainsi que dans les méthodes dérivées.

Également dans la méthode principale, la référence parent est utilisée pour appeler la méthode enfant. Ainsi, dans ce cas, lorsqu'aucun mot-clé n'est utilisé, la méthode parent est appelée à la place d'une méthode enfant. Le résultat sera donc

Sortie :

Exemple 2 (a) - Avec des mots-clés virtuels et de remplacement

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird   // base class
{
public virtual void fly()   // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public override void fly()   // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Bird b = new Peacock();
b.fly();
Console.ReadLine();
}
}
}

Dans cet exemple, virtual est utilisé dans la classe de base, ce qui signifie qu'il donne le pouvoir à la classe enfant d'implémenter la méthode à sa manière. Dans une classe dérivée, le remplacement est utilisé, ce qui signifie que la méthode enfant est la méthode de remplacement. Les deux méthodes sont identiques avec le même nom et la même signature de méthode mais la partie implémentation est différente. Dans cet exemple également, la référence parent est utilisée pour appeler la méthode enfant. Mais comme un parent est une méthode virtuelle, la méthode enfant est appelée en premier au lieu de la méthode parent. Le résultat sera donc

Sortie :

Exemple 2 (b) – Mots-clés virtuels et de remplacement

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird  // base class
{
public virtual void fly()   // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public override void fly()  // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
//main method
static void Main(string[] args)
{
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
}
}
}

Cet exemple est le même que l'exemple précédent mais cette méthode enfant est utilisée à titre de référence.

Sortie : 

Exemple 3 – Avec mot-clé de base

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird  // base class
{
public virtual void fly()  // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird  // derived class
{
public override void fly()  // derived class method
{
base.fly();  // base is use to call parent method
Console.WriteLine("Peacock is flying");
}
}
class Program
{
static void Main(string[] args)
{
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, la base est utilisée dans une classe dérivée pour appeler la méthode de la classe de base. Donc dans cette méthode de base est appelée d'abord, puis la méthode dérivée.

Sortie :

Exemple 4 – Classes abstraites avec remplacement

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
abstract class Calculate
{
public abstract int sum();
}
class Values : Calculate // derived class
{
int val1;
int val2;
public Values(int a = 0, int b = 0)
{
val1 = a;
val2 = b;
}
public override int sum()
{
Console.WriteLine("sum of two values");
return (val1 + val2);
}
}
class Program
{
static void Main(string[] args)
{
Values v = new Values(10, 20);
int a = v.sum();
Console.WriteLine(a);
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, une méthode abstraite est utilisée. Une classe abstraite est implémentée par la classe dérivée qui contient une méthode abstraite.

Sortie : 

Règles de remplacement de méthode

• La signature de méthode d'une classe dérivée doit être la même que celle d'une classe de base.
• Le remplacement n'est pas possible dans la même classe.
• Les modificateurs d'accès doivent être les mêmes pour les méthodes virtuelles et les méthodes de remplacement.
• Le mot-clé virtuel est utilisé dans la méthode de classe de base et Override est utilisé dans une méthode de classe dérivée.
• La méthode de la classe de base ne doit pas être statique.

Conclusion

La substitution est utile dans le polymorphisme d'exécution. Il permet à une classe dérivée d'implémenter une méthode de classe de base à sa manière. L’implémentation de la méthode est donc différente de la classe dérivée à la classe de base. La méthode remplacée peut être virtuelle, override ou abstraite.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!