Page d'Accueil

Les Classes Génériques

 

Introduction

Comme est habituellement fait, vous imaginer pour vouloir passer différents types de valeurs à de diverses méthodes de classe pour accomplir principalement le même but. Vous pouvez être tentés à avez surchargé une méthode dans diverses versions comme suit :

using System;

public class Exercise
{
    // Display the value of an integer
    public void Show(int value)
    {
        Console.WriteLine(value);
    }

    // Display the value of a double-precesion value
    public void Show(double value)
    {
        Console.WriteLine(value);
    }

    // Display the value of a character
    public void Show(char value)
    {
        Console.WriteLine(value);
    }
}
public class Program
{
    static int Main()
    {
        Exercise exo = new Exercise();
        
        // Call the version of the method that displays an integer
        exo.Show(246);
        
        // Call the version of the method that displays a character
        exo.Show('G');
        
        // Call the version of the method that displays a decimal
        exo.Show(355.65);
        
        return 0;
    }
}

Ceci produirait :

246
G
355.65
Press any key to continue . . .

Nous avons passé une valeur constante directement à la méthode quand nous l'avons appelée. Se rappeler que vous peut également d'abord déclarer une variable, lui assigner une valeur, et puis passer cette variable à la méthode. Voici les exemples :

public class Program
{
    static int Main()
    {
        Exercise exo = new Exercise();

        // Call the version of the method that displays an integer
        int Value1 = 246;
        exo.Show(Value1);

        // Call the version of the method that displays a character
        char Value2 = 'G';
        exo.Show(Value2);

        // Call the version of the method that displays a decimal
        double Value3 = 355.65;
        exo.Show(Value3);

        return 0;
    }
}

Bien que ceci soit basé sur le concept de la méthode surchargeant, une autre manière que vous pouvez résoudre ce type de problème est de créer une méthode qui ne connaît pas le type de valeur qui lui serait passé mais la méthode est équipée pour traiter la valeur convenablement. Basé sur le programme ci-dessus, vous pouvez créer une méthode qui prend un argument et il montre sa valeur. Pour faire ceci, lorsque vous définissez la méthode, vous l'avez seulement faite savoir qu'elle recevrait un argument mais vous n'indiquez pas le type de valeur qu'il traitera. Une telle méthode désigné sous le nom générique.

Étude pratiqueÉtude pratique : Présentation des médicaments génériques

  1. Commencer Microsoft Visual C# et créer une application de console appelée CommercialStore1
  2. Pour créer une nouvelle classe, sur le menu principal, projet de clic - > ajouter la classe…
  3. Placer le nom à StoreItem et la pression entrent
  4. Changer le dossier comme suit :
     
    using System;
    
    namespace CommercialStore1
    {
        class StoreItem
        {
            public class CItem
            {
                public double Item;
                public CItem Next;
            }
    
            public CItem Head = null;
            public int Size;
    
            public int Count()
            {
                return Size;
            }
    
            public int Add(CItem NewItem)
            {
                CItem Sample = new CItem();
    
                Sample = NewItem;
                Sample.Next = Head;
                Head = Sample;
    
                return Size++;
            }
    
            public CItem Retrieve(int Position)
            {
                CItem Current = Head;
    
                for (int i = Count() - 1; i > Position && Current != null; i--)
                {
                    Current = Current.Next;
                }
    
                return Current;
            }
    
            public void ShowItem(double item)
            {
                Console.WriteLine("Item: {0}", item);
            }
        }
    }
  5. L'Access le dossier de Program.cs et le changent comme suit :
     
    using System;
    
    namespace CommercialStore1
    {
        class Program
        {
            static int Main()
            {
                StoreItem exo = new StoreItem();
                StoreItem.CItem Part;
    
                Part = new StoreItem.CItem();
                Part.Item = 97.43;
                exo.Add(Part);
    
                Part = new StoreItem.CItem();
                Part.Item = 274.87;
                exo.Add(Part);
    
                Part = new StoreItem.CItem();
                Part.Item = 8.7873;
                exo.Add(Part);
    
                Part = new StoreItem.CItem();
                Part.Item = 2764.4;
                exo.Add(Part);
    
                Part = new StoreItem.CItem();
                Part.Item = 92.4662;
                exo.Add(Part);
    
                Part = new StoreItem.CItem();
                Part.Item = 66800.85;
                exo.Add(Part);
    
                Console.WriteLine("-=- List of Items -=-");
    
                for (int i = 0; i < exo.Count(); i++)
                {
                    StoreItem.CItem One = exo.Retrieve(i);
    
                    exo.ShowItem(One.Item);
                }
    
                Console.WriteLine("\nNumber of Items: {0}\n", exo.Count());
                return 0;
            }
        }
    }
  6. Exécuter l'application pour voir le résultat
     
    -=- List of Items -=-
    Item: 97.43
    Item: 274.87
    Item: 8.7873
    Item: 2764.4
    Item: 92.4662
    Item: 66800.9
    
    Number of Items: 6
    
    Press any key to continue . . .
  7. Fermer la fenêtre de DOS

Création générique de méthode

Une méthode générique est une méthode qui peut traiter une valeur dont le type est connu seulement quand la variable est accédée. Pour créer une méthode générique, du bon côté du nom de la méthode, dactylographier l'opérateur de <>. À l'intérieur de de cet opérateur, écrire une lettre ou un nom, qui désigné sous le nom du type de paramètre. Voici un exemple :

public class Exercise
{
    public void Show<TypeOfValue>()
    {
    }
}

Une des manières que vous pouvez employer le type de paramètre est de passer un argument à la méthode. Vous faites ceci en précédant le nom de l'argument avec le type de paramètre. Voici un exemple :

public class Exercise
{
    public void Show<TypeOfValue>(TypeOfValue value)
    {
    }
}

Dans le corps de la méthode, vous pouvez traiter l'argument pendant que vous voyez l'ajustement. À un minimum, et basé sur notre programme plus tôt, vous pouvez simplement montrer la valeur en la passant à la méthode de Console.WriteLine (). Voici un exemple :

public class Exercise
{
    public void Show<TypeOfValue>(TypeOfValue value)
    {
        Console.WriteLine(value);
    }
}

Par la tradition, la plupart des programmeurs et la plupart des documents emploient la lettre T pour le type de paramètre.

Étude pratiqueÉtude pratique : Créer une méthode générique

  1. Pour créer une méthode générique, changer la méthode de ShowItem () comme suit :
     
    public void ShowItem<T>(T item)
    {
          Console.WriteLine("Item: {0}", item);
    }
  2. Économiser le dossier

J'appelle une méthode générique

Comme cité précédemment, une des particularités d'une méthode générique est que, lorsqu'elle est définie, la méthode ne connaît pas le type du paramètre. Ceci signifie que, en appelant la méthode, vous devez s'assurer vous clairement indiquer le type de valeur qui sera traité. Vous pouvez faire ceci en passant directement (une constante de) le type de valeur que la méthode traitera. Voici les différents exemples d'appeler notre méthode d'exposition () :

using System;

public class Exercise
{
    public void Show<TypeOfValue>(TypeOfValue value)
    {
        Console.WriteLine(value);
    }
}

public class Program
{
    static int Main()
    {
        Exercise exo = new Exercise();

        // Call the version of the function that displays an integer
        int Value1 = 246;
        exo.Show(Value1);

        // Call the version of the function that displays a character
        char Value2 = 'G';
        exo.Show(Value2);

        // Call the version of the function that displays a decimal
        double Value3 = 355.65;
        exo.Show(Value3);
        
        return 0;
    }
}

Une fois conformé et exécuté, ce programme produirait :

246
G
355.65
Press any key to continue . . .

Comme alternative, vous pouvez dactylographier le nom de la méthode, suivi des équerres. À l'intérieur de des parenthèses, écrire le type de données de la valeur qui sera traitée. Après les équerres, ouvrir les parenthèses et, à l'intérieur de de elles, dactylographier la valeur constante qui sera traitée. Voici les exemples :

using System;

public class Exercise
{
    public void Show<TypeOfValue>(TypeOfValue value)
    {
        Console.WriteLine(value);
    }
}

public class Program
{
    static int Main()
    {
        Exercise exo = new Exercise();

        // Call the version of the function that displays an integer
        int Value1 = 246;
        exo.Show<int>(Value1);

        // Call the version of the function that displays a character
        char Value2 = 'G';
        exo.Show<char>(Value2);

        // Call the version of the function that displays a decimal
        double Value3 = 355.65;
        exo.Show<double>(Value3);
        
        return 0;
    }
}

Vous pouvez également déclarer la valeur comme constante avant de la passer à la méthode.

Étude pratiqueÉtude pratique : J'appelle une méthode générique

  1. Pour indiquer le type de paramètre d'une méthode générique en l'appelant, changer () la méthode principale comme suit :
     
    class Program
    {
        static int Main()
        {
            . . .
    
            Console.WriteLine("-=- List of Items -=-");
    
            for (int i = 0; i < exo.Count(); i++)
            {
                Exercise.CItem One = exo.Retrieve(i);
    
                exo.ShowItem<double>(One.Item);
            }
    
            Console.WriteLine("\nNumber of Items: {0}\n", exo.Count());
            return 0;
        }
    }
  2. Exécuter l'application et noter que cela fonctionne très bien
  3. Fermer la fenêtre de DOS
 

Précédent Copyright © 2007, Yevol Suivant