Page d'Accueil

Délégués
 

Introduction

Les langages C et C++ ont longtemps utilisé le concept d'indicateur de fonction. C'était bien plus utile en programmant pour les logiciels d'exploitation de Microsoft Windows parce que la bibliothèque Win32 est fondée sur le concept des fonctions de rappel. Les fonctions de rappel sont utlisées dans la programmation de Microsoft Windows pour traiter les messages. Pour cette raison et en raison de leur fonctionnalité, des fonctions de rappel ont été transportées dans .NET Framework mais elles ont été définies par le nom délégué.

Un délégué est un type spécial de variable définie pour l'utilisateur et est déclarée globalement, comme une classe. Un délégué fournit un modèle pour une méthode, comme une interface fournit un modèle pour une classe. Comme une interface, un délégué n'est pas défini. Son rôle est de montrer à quoi ressemblerait une méthode utile. Pour soutenir ce concept, un délégué peut fournir toute information nécessaire qui serait utilisée sur une méthode. Ceci inclut un type de retour, aucun argument ou un ou plusieurs arguments.
 

Étude pratiqueÉtude pratique : Présentation des délégués
  1. Commencez Microsoft Visual C# et créer une application de console appelée WattsALoan1
  2. Pour créer une nouvelle classe, sur le menu principal, cliquez projet - > Ajouter la classe…
  3. Changez le nom du fichier en LoanEvaluation et lcliquez Ajouter
  4. Changez le contenu du fichier comme suit :
      
    using System;

namespace WattsALoan1
{
    class LoanEvaluation
    {
        public double GetPrincipal()
        {
            Console.Write("Enter the Principal:         $");
            double P = double.Parse(Console.ReadLine());

            return P;
        }

        public double GetInterestRate()
        {
            Console.Write("Enter the Interest Rate (%): ");
            double r = double.Parse(Console.ReadLine());

            return r;
        }

        public int GetPeriod()
        {
            Console.Write("Enter the number of months:  ");
            int t = int.Parse(Console.ReadLine());

            return t;
        }
    }
}
  5. Accédez au fichier Program.cs et changez le comme suit :
      
    using System;

namespace WattsALoan1
{
    class Program
    {
        static int Main()
        {
            int NumberOfPeriods;
            double Principal, IntRate;
            LoanEvaluation loan = new LoanEvaluation();

	    Console.WriteLine(
	"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
            Console.WriteLine("Loan Processing\n");
	    Console.WriteLine(
		"This program allows you to calculate the amount of money a ");
	    Console.WriteLine(
		"customer will owe at the end of the lifetime of a loan\n");

            Principal = loan.GetPrincipal();
            IntRate = loan.GetInterestRate();
            NumberOfPeriods = loan.GetPeriod();
	    Console.WriteLine(
		"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");

            Console.WriteLine("================================");
            Console.WriteLine("Loan Estimation");
            Console.WriteLine("--------------------------------");
            Console.WriteLine("Principal: {0:C}", Principal);
            Console.WriteLine("Interest:  {0:P}", IntRate / 100);
            Console.WriteLine("Period:    {0} months", NumberOfPeriods);
            Console.WriteLine("================================\n");

            return 0;
        }
    }
}
  6. Exécutez l'application qui le testel.
    Voici un exemple :
      
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Loan Processing

This program allows you to calculate the amount of money a
customer will owe at the end of the lifetime of a loan

Enter the Principal:         $14500
Enter the Interest Rate (%): 12.25
Enter the number of months:  48
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

================================
Loan Estimation
--------------------------------
Principal: $14,500.00
Interest:  12.25 %
Period:    48 months
================================

Press any key to continue . . .
  7. Fermez la fenêtre DOS
  8. Dans le programme ci-dessus, le commis a été invité à fournir le nombre de mois pour la période du prêt. Selon le prêt, un client peut vouloir indiquer le nombre de jours nécessaires pour payer le prêt. Un autre client peut vouloir payer un prêt sur un certain nombre d'années. Pour rendre ceci possible, nous permettrons au commis de choisir le type de période pour un prêt.


    Accédez au fichier LoanProcecssing.cs et changez le fichier comme suit :
     

    using System;

namespace WattsALoan1
{
    class LoanEvaluation
    {
        public double GetPrincipal()
        {
            Console.Write("Enter the Principal:         $");
            double P = double.Parse(Console.ReadLine());

            return P;
        }

        public double GetInterestRate()
        {
            Console.Write("Enter the Interest Rate (%): ");
            double r = double.Parse(Console.ReadLine());

            return r;
        }

        public void GetPeriod(ref int TypeOfPeriod, ref int Periods)
        {
            Console.WriteLine("How do you want to enter the length of time?");
            Console.WriteLine("1 - In Days");
            Console.WriteLine("2 - In Months");
            Console.WriteLine("3 - In Years");
            Console.Write("Your Choice: ");
            TypeOfPeriod = int.Parse(Console.ReadLine());

            if (TypeOfPeriod == 1)
            {
                Console.Write("Enter the number of days: ");
                Periods = int.Parse(Console.ReadLine());
            }
            else if (TypeOfPeriod == 2)
            {
                Console.Write("Enter the number of months: ");
                Periods = int.Parse(Console.ReadLine());
            }
            else if (TypeOfPeriod == 3)
            {
                Console.Write("Enter the number of years: ");
                Periods = int.Parse(Console.ReadLine());
            }
            else
            {
                TypeOfPeriod = 0;
                // The user made an invalid selection. So, we will give up
                Console.WriteLine("Bad Selection\n");
            }
        }
    }
}
  9. Accédez au fichier Program.cs et le changer comme suit :
      
    using System;

namespace WattsALoan1
{
    class Program
    {
        static int Main()
        {
            int Periods = 0;
            int TypeOfPeriod = 0;
            double Principal, IntRate;
            string PeriodName = null;
            LoanEvaluation loan = new LoanEvaluation();

	    Console.WriteLine(
	"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
	    Console.WriteLine(
	"This program allows you to calculate the amount of money a ");
	    Console.WriteLine(
	"customer will owe at the end of the lifetime of a loan\n");

            Console.WriteLine("Loan Processing\n");
            Principal = loan.GetPrincipal();
            IntRate = loan.GetInterestRate();

            loan.GetPeriod(ref TypeOfPeriod, ref Periods);
            if (TypeOfPeriod == 0)
            {
                // Since the user made a bad selection, stop the program here
                return 0;
            }   // Since this "if" condition has a "return 0" line, if the "if"
            // condition produces true, the "return 0" means the function
            // would be terminated. If the condition is false, the inside of
            // this "if" condition would not execute and the function would
            // continue. This means that, if the condition is false, then
            // the "else' is implied. Therefore, we don't have to write an
            // "else" condition: it is automatic.

            if (TypeOfPeriod == 1)
            {
                PeriodName = "days";
            }
            else if (TypeOfPeriod == 2)
            {
                PeriodName = "months";
            }
            else if (TypeOfPeriod == 3)
            {
                PeriodName = "years";
            }

	    Console.WriteLine(
	"%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");

            Console.WriteLine("==================================");
            Console.WriteLine("Loan Estimation");
            Console.WriteLine("----------------------------------");
            Console.WriteLine("Principal: {0:C}", Principal);
            Console.WriteLine("Interest:  {0:P}", IntRate / 100);
            Console.WriteLine("Period:    {0} {1}", Periods, PeriodName);
            Console.WriteLine("==================================\n");

            return 0;
        }
    }
}
  10. Exécutez l'application et l'examiner. Voici un exemple :
      
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
This program allows you to calculate the amount of money a
customer will owe at the end of the lifetime of a loan

Loan Processing

Enter the Principal:         $7500.00
Enter the Interest Rate (%): 8.75
How do you want to enter the length of time?
1 - In Days
2 - In Months
3 - In Years
Your Choice: 3
Enter the number of years: 4
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
==================================
Loan Estimation
----------------------------------
Principal: $7,500.00
Interest:  8.75 %
Period:    4 years
==================================

Press any key to continue . . .
  11. Fermez la fenêtre DOS

Créer un délégué

Pour créer un délégué, vous utilisez le mot-clé delegate. La formule de base créant un délégué est :

[attributes] [modifiers] delegate ReturnType Name ([formal-parameters]);

Le facteur d'attributs peut être un attribut normal de C# .

Le modificateur peut être l'un ou une combinaison appropriée des mots-clés suivants : new, public, private, protected, ou internal.

Le mot-clé delegate est exigé.

Le ReturnType peut être n'importe la=equel des types de données que nous avons utilisés jusqu'ici. Ce peut également être un type void ou le nom d'une classe.

Le nom doit être un nom valide de C#.

Puisqu'un délégué est un certain type de modèle pour une méthode, vous devez utiliser des parenthèses, exigées pour chaque méthode. Si cette méthode ne prendra aucun argument, vous pouvez laisser les parenthèses vides.

Voici un exemple :

using System;

delegate void dlgSimple();

class Exercise
{
    static int Main()
    {
	return 0;
    }
}

Après la déclaration d'un délégué, se rappeler qu'il fournit seulement un modèle pour une méthode, pas une méthode réelle. Afin de l'utiliser, vous devez définir une méthode qui porterait une petite tâche à exécuter. Cette méthode doit avoir le même type de retour et les mêmes (nombre) d'arguments éventuellement. Par exemple, le délégué ci-dessus déclaré est de type void et il ne prend aucun argument. vous pouvez définir une méthode correspondante comme suit :

using System;

delegate void dlgSimple();

class Exercise
{
    private static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }

    static int Main()
    {
	return 0;
    }
}

Une telle méthode étant appliqué, vous pouvez l'associer au nom du délégué. Pour faire cela, là où vous voulez utiliser la méthode, déclarez d'abord une variable du type délégué en utilisant l'opérateur new. Dans les parenthèses du constructeur, passez le nom de la méthode. Voici un exemple

using System;

delegate void dlgSimple();

class Exercise
{
    private static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }

    static int Main()
    {
	dlgSimple Announce = new dlgSimple(Welcome);

	return 0;
    }
}

Cette déclaration donne la signification au délégué déclaré. Pour utiliser réellement la méthode, appelez le nom du délégué comme si c'était une méthode définie. Voici un exemple :

using System;

delegate void dlgSimple();

class Exercise
{
    private static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }

    static int Main()
    {
	dlgSimple Announce = new dlgSimple(Welcome);

	Announce();
	return 0;
    }
}

Ceci produirait :

Welcome to the Wonderful World of C# Programming!

Vous pouvez également déclarer un délégué qui renvoie une valeur. En définissant une méthode qui serait associée au délégué, se rappeler que la méthode doit renvoyer le même type de valeur. Voici un exemple :
 
using System;

delegate void dlgSimple();
delegate double Addition();

class Exercise
{
    private static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }

    private static double Plus()
    {
	double a = 248.66, b = 50.28;

	return a + b;
    }

    static int Main()
    {
	dlgSimple Announce = new dlgSimple(Welcome);
	Addition  Add = new Addition(Plus);

	Announce();
	Console.WriteLine("\n248.66 + 50.26 = {0}", Add());
	return 0;
    }
}

Ceci produirait :

Welcome to the Wonderful World of C# Programming!

248.66 + 50.26 = 298.94

Étude pratique Étude pratique : Utiliser un délégué
  1. Accédez au fichier LoanEvaluation.cs et changez le comme suit :
      
    using System;

namespace WattsALoan1
{
    class LoanEvaluation
    {
        public double GetPrincipal()
        {
            Console.Write("Enter the Principal:         $");
            double P = double.Parse(Console.ReadLine());

            return P;
        }

        public double GetInterestRate()
        {
            Console.Write("Enter the Interest Rate (%): ");
            double r = double.Parse(Console.ReadLine());

            return r;
        }

        public double GetPeriod(ref int TypeOfPeriod, ref double Periods)
        {
            Console.WriteLine("How do you want to enter the length of time?");
            Console.WriteLine("1 - In Days");
            Console.WriteLine("2 - In Months");
            Console.WriteLine("3 - In Years");
            Console.Write("Your Choice: ");
            TypeOfPeriod = int.Parse(Console.ReadLine());

            if (TypeOfPeriod == 1)
            {
                Console.Write("Enter the number of days: ");
                Periods = double.Parse(Console.ReadLine());
                return Periods / 360;
            }
            else if (TypeOfPeriod == 2)
            {
                Console.Write("Enter the number of months: ");
                Periods = double.Parse(Console.ReadLine());
                return Periods / 12;
            }
            else if (TypeOfPeriod == 3)
            {
                Console.Write("Enter the number of years: ");
                Periods = double.Parse(Console.ReadLine());
                return Periods;
            }
            else
            {
                TypeOfPeriod = 0;
                // The user made an invalid selection. So, we will give up
                Console.WriteLine("Bad Selection\n");
                return 0.00;
            }
        }

        // Interest = Principal * rate * time in years
        public double InterestAmount(double P, double r, double t)
        {
            return P * (r / 100) * t;
        }
    }
}
  2. Accédez au fichier Program.cs
  3. Pour déclarer et utiliser un délégué, changez le fichier Program.cs comme suit :
      
    using System;

namespace WattsALoan1
{
    delegate double Add2Values(double Value1, double Value2);

    class Exercise
    {
        static int Main()
        {
            double Principal, IntRate, Period, AmountPaidAsInterest;
            int TypeOfPeriod = 0;
            double Periods = 0D;
            string PeriodName = null;
            LoanEvaluation loan = new LoanEvaluation();

            Add2Values Add = new Add2Values(Addition);

            Console.WriteLine("\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%");
	    Console.WriteLine(
	"This program allows you to calculate the amount of money a ");
	    Console.WriteLine(
	"customer will owe at the end of the lifetime of a loan\n");

            Console.WriteLine("Loan Processing\n");
            Principal = loan.GetPrincipal();
            IntRate   = loan.GetInterestRate();
            Period    = loan.GetPeriod(ref TypeOfPeriod, ref Periods);
            AmountPaidAsInterest =
		 loan.InterestAmount(Principal, IntRate, Period);
            double Amount = Add(Principal, AmountPaidAsInterest);

            if (TypeOfPeriod == 0)
            {
                // Since the user made a bad selection, stop the program here
                return 0;
            }   // Since this "if" condition has a "return 0" line, if the "if"
            // condition produces true, the "return 0" means the function
            // would be terminated. If the condition is false, the inside of
            // this "if" condition would not execute and the function would
            // continue. This means that, if the condition is false, then
            // the "else' is implied. Therefore, we don't have to write an
            // "else" condition: it is automatic.

            if (TypeOfPeriod == 1)
            {
                PeriodName = "days";
            }
            else if (TypeOfPeriod == 2)
            {
                PeriodName = "months";
            }
            else if (TypeOfPeriod == 3)
            {
                PeriodName = "years";
            }

            Console.WriteLine("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");

            Console.WriteLine("==================================");
            Console.WriteLine("Estimate on loan");
            Console.WriteLine("----------------------------------");
            Console.WriteLine("Principal: {0:C}", Principal);
            Console.WriteLine("Interest:  {0:P}", IntRate / 100);
            Console.WriteLine("Period:    {0} {1}", Periods, PeriodName);
            Console.WriteLine("--------------------------------");
            Console.WriteLine("Total Amount Paid:     {0:C}", Amount);
            Console.WriteLine("Interest paid on Loan: {0:C}", 
				AmountPaidAsInterest);
            Console.WriteLine("==================================\n");

            return 0;
        }

        static double Addition(double Value1, double Value2)
        {
            return Value1 + Value2;
        }
    }
}
  4. Exécutez le programme et l'examiner. Voici un exemple :
      
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
This program allows you to calculate the amount of money a
customer will owe at the end of the lifetime of a loan

Loan Processing

Enter the Principal:         $12500
Enter the Interest Rate (%): 10.55
How do you want to enter the length of time?
1 - In Days
2 - In Months
3 - In Years
Your Choice: 2
Enter the number of months: 42
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

==================================
Estimate on loan
----------------------------------
Principal: $12,500.00
Interest:  10.55 %
Period:    42 months
--------------------------------
Total Amount Paid:     $17,115.63
Interest paid on Loan: $4,615.63
==================================

Press any key to continue . . .
  5. Revenez au fichier Exercise.cs

Délégués et classes

Dans les introductions ci-dessus, nous avons associé les délégués avec uniquement la méthode de la classe Main. Puisque les délégués sont habituellement déclarés globalement, c'est à dire en dehors d'une classe, ils peuvent être associés à une méthode de n'importe quelle classe, si la méthode a le même type de retour (et les mêmes (nombre) d'arguments) que le délégué. Quand nous avons créé les méthodes de classe Main, nous les avons définies en tant que statiques, puisque toutes les méthodes de classe Main doivent être déclarées statiques.

Les méthodes de n'importe quelle classe peuvent également être associées aux délégués. Voici un exemple de deux méthodes liées à un même délégué:

 
using System;

namespace CSharpLessons
{
	delegate double Multiplication();

	public class Cube
	{
		private double _side;

		public double Side
		{
			get { return _side; }

			set	{ _side = value; }
		}

		public Cube()
		{
			_side = 0;
		}

		public Cube(double s)
		{
			_side = s;
		}

		public double Area()
		{
			return 6 * Side * Side;
		}

		public double Volume()
		{
			return Side * Side * Side;
		}

		public void CubeCharacteristics()
		{
			Multiplication AreaDefinition = new Multiplication(Area);
			Multiplication VolDefinition  = new Multiplication(Volume);

			Console.WriteLine("Cube  Characteristics");
			Console.WriteLine("Side:   {0}", Side);
			Console.WriteLine("Area:   {0}", AreaDefinition());
			Console.WriteLine("Volume: {0}\n", VolDefinition());
		}
	}

	class Exercise
	{
		static int Main()
		{
			Cube SmallBox = new Cube(25.58);

			SmallBox.CubeCharacteristics();
			return 0;
		}
	}
}

Ceci produirait :

Cube  Characteristics
Side:   25.58
Area:   3926.0184
Volume: 16737.925112

Compositions de délégués

Une des caractéristiques qui differentie les délégués des indicateurs de fonction de C/C++ est qu'un délégué peut être ajouté à l'autre en utilisant l'opération +. Ceci désigné sous sous le nom de composition. Ceci est fait en ajoutant une variable déléguée à une autre comme dans a= b + C.
 
Page d'Accueil Copyright © 2007, Yevol Suivant