Comment les opérateurs arithmétiques peuvent-ils être surchargés pour les classes génériques en C# avec la prise en charge des opérations arithmétiques ?

Surcharge d'opérateur arithmétique de classe générique C#

Définir des opérateurs arithmétiques à l'aide de classes génériques en C# peut être un défi. Cela est particulièrement vrai lorsqu'un type générique est limité à un type spécifique prenant en charge les opérations arithmétiques. Explorons un scénario spécifique pour illustrer ce défi et proposer une solution possible.

Considérez la définition de classe générique suivante modélisant les nombres restreints :

<code class="language-csharp">public class ConstrainedNumber<T> :
    IEquatable<ConstrainedNumber<T>>,
    IEquatable<T>,
    IComparable<ConstrainedNumber<T>>,
    IComparable<T>,
    IComparable
    where T : struct, IComparable, IComparable<T>, IEquatable<T></code>

Cette classe représente un nombre restreint, prenant en charge les comparaisons d'égalité et l'ordre naturel. Cependant, pour effectuer des opérations arithmétiques sur les instances de cette classe, nous devons définir les opérateurs correspondants.

Une façon consiste à définir un opérateur comme ceci :

<code class="language-csharp">public static T operator +(ConstrainedNumber<T> x, ConstrainedNumber<T> y)
{
    return x._value + y._value;
}</code>

Cependant, cette approche ne parvient pas à être compilée car l'opérateur « » ne peut pas être appliqué directement au type « T ». Pour résoudre ce problème, nous avons besoin d'une contrainte pour spécifier que « T » est un type qui prend en charge les opérations arithmétiques. Malheureusement, une telle contrainte n’existe pas en C#.

Comme alternative, nous pouvons utiliser l'interface IConvertible comme contrainte et convertir manuellement 'T' en un type adapté pour effectuer des opérations arithmétiques :

<code class="language-csharp">public static T operator +(T x, T y)
    where T : IConvertible
{
    var type = typeof(T);
    if (type == typeof(string) ||
        type == typeof(DateTime)) throw new ArgumentException(string.Format("The type {0} is not supported", type.FullName), "T");

    try
    {
        return (T)(object)(x.ToDouble(NumberFormatInfo.CurrentInfo) + y.ToDouble(NumberFormatInfo.CurrentInfo));
    }
    catch (Exception ex)
    {
        throw new ApplicationException("The operation failed.", ex);
    }
}</code>

Cette méthode utilise l'interface IConvertible pour convertir « T » en double, effectuer l'opération arithmétique, puis reconvertir le résultat en type « T ». Cependant, il est important de noter que cette approche peut ne pas convenir à tous les scénarios et devra peut-être être personnalisée en fonction des besoins spécifiques de l'application.

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!