0Pricing
C# Academy · Leçon

Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire)

Émulez le calcul générique sans fonctionnalités modernes : transmettez un fournisseur d’opérations ou des délégués, contraignez soigneusement les types et simulez les « attributs génériques » au moyen de paramètres Type.

Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire) est une leçon C# Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C# Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C# Academy comprend 3 leçons au total.

Calcul générique en C# 6

Objectif : écrire des algorithmes numériques génériques en C# 6.

  • Pas d’opérateurs statiques abstraits sur T
  • Solutions de remplacement : une interface de fournisseur d’opérations ou de petits délégués
  • Pour les annotations, utilisez des attributs avec des paramètres Type

Modèle du fournisseur d’opérations

Fournissez Zero et Add via une interface. L’algorithme générique appelle ces méthodes au lieu d’utiliser + sur T.

using System;
using System.Collections.Generic;

public interface INumericOps<T>
{
  T Zero { get; }
  T Add(T a, T b);
}

public sealed class IntOps : INumericOps<int>
{
  public int Zero { get { return 0; } }
  public int Add(int a, int b) { return a + b; }
}

public sealed class DoubleOps : INumericOps<double>
{
  public double Zero { get { return 0.0; } }
  public double Add(double a, double b) { return a + b; }
}

public class Program
{
  static T Sum<T>(IEnumerable<T> items, INumericOps<T> ops)
  {
    T acc = ops.Zero;
    foreach (T x in items) acc = ops.Add(acc, x);
    return acc;
  }

  public static void Main(string[] args)
  {
    int s1 = Sum(new int[] {1,2,3}, new IntOps());
    double s2 = Sum(new double[] {1.5, 2.0}, new DoubleOps());
    Console.WriteLine("Sum int = " + s1);
    Console.WriteLine("Sum double = " + s2);
  }
}

Moyenne avec des assistants

Pour les opérations que vous ne pouvez pas exprimer de façon générique, comme la division, transmettez un petit convertisseur ou un délégué supplémentaire.

using System;
using System.Collections.Generic;

public interface INumericOps<T>
{
  T Zero { get; }
  T Add(T a, T b);
}

public sealed class DoubleOps : INumericOps<double>
{
  public double Zero { get { return 0.0; } }
  public double Add(double a, double b) { return a + b; }
}

public class Program
{
  static double Average<T>(IEnumerable<T> items, INumericOps<T> ops, Func<T,double> toDouble)
  {
    T acc = ops.Zero;
    int count = 0;
    foreach (T x in items) { acc = ops.Add(acc, x); count++; }
    if (count == 0) throw new ArgumentException("Empty sequence", "items");
    // convert with a delegate for division
    return toDouble(acc) / count;
  }

  public static void Main(string[] args)
  {
    double avg = Average<double>(new double[] {2.0, 4.0, 6.0}, new DoubleOps(), delegate(double d) { return d; });
    Console.WriteLine("Avg = " + avg);
  }
}

Réduction fondée sur un délégué

Les délégués permettent de rester minimaliste : transmettez une valeur initiale et une fonction de combinaison. C’est adapté aux petits utilitaires.

using System;

public class Program
{
  static T Fold<T>(T[] xs, T seed, Func<T,T,T> combine)
  {
    T acc = seed;
    for (int i = 0; i < xs.Length; i++) acc = combine(acc, xs[i]);
    return acc;
  }

  public static void Main(string[] args)
  {
    int sum = Fold<int>(new int[] {1,2,3}, 0, delegate(int a, int b) { return a + b; });
    double sumD = Fold<double>(new double[] {1.5, 2.5}, 0.0, delegate(double a, double b) { return a + b; });
    Console.WriteLine("Sum ints = " + sum);
    Console.WriteLine("Sum doubles = " + sumD);
  }
}

Solution de remplacement avec un attribut

C# 6 ne prend pas réellement en charge les attributs génériques. Transmettez un Type à l’attribut pour indiquer le type générique associé.

using System;
using System.Reflection;

// C# 6 cannot declare generic attributes. Workaround: pass a Type.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class ValidatorForAttribute : Attribute
{
  public Type TargetType { get; private set; }
  public ValidatorForAttribute(Type targetType) { TargetType = targetType; }
}

public sealed class Customer { public string Name; }

[ValidatorFor(typeof(Customer))]
public sealed class CustomerValidator
{
  public bool IsValid(Customer c) { return c != null && !string.IsNullOrEmpty(c.Name); }
}

public class Program
{
  public static void Main(string[] args)
  {
    Type t = typeof(CustomerValidator);
    object[] attrs = t.GetCustomAttributes(typeof(ValidatorForAttribute), false);
    if (attrs.Length > 0)
    {
      ValidatorForAttribute a = (ValidatorForAttribute)attrs[0];
      Console.WriteLine("Validator targets: " + a.TargetType.Name);
    }
  }
}

Conseils et choix

Conseils :

  • Privilégiez un fournisseur d’opérations pour les algorithmes numériques réutilisables.
  • Utilisez des délégués pour les petits assistants (combiner, convertir).
  • Pour les annotations, transmettez Type dans les attributs et lisez-le par réflexion.

Solution de remplacement pour le calcul générique

Vérification rapide : dans C# 6, quelle est une manière pratique d’écrire un Sum<T> générique sans le calcul générique moderne ?

Récapitulatif

Récapitulatif : sans le calcul générique moderne, transmettez des opérations ou des délégués à vos algorithmes. Pour les annotations, utilisez des attributs qui contiennent un Type, puis lisez-le par réflexion.

Questions Fréquemment Posées

La leçon « Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire) » est-elle gratuite ?

Oui — le texte complet de « Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C# Academy, passe à CoddyKit PRO. Le cours C# Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire) » ?

Émulez le calcul générique sans fonctionnalités modernes : transmettez un fournisseur d’opérations ou des délégués, contraignez soigneusement les types et simulez les « attributs génériques » au moye… Tu pratiques C# Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C# Academy ?

Aucune expérience préalable n'est requise. C# Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C# Academy ?

Oui. Chaque leçon C# Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. unmanaged, notnull et new() (émulation en C# 6)
  2. Calcul générique (vue d’ensemble) et attributs génériques (si nécessaire)
  3. Utilitaires génériques réutilisables
← Retour à C# Academy