Délégués et arguments

Un délégué qui prend un ou plus d'arguments

Si vous voulez associer une méthode qui prend des arguments à un délégué, en déclarant le délégué, fournissez les arguments nécessaires dans ses parenthèses. Voici un exemple d'un délégué qui prend deux arguments (et retourne une valeur) :

delegate double Addition(double x, double y);

Quand vous définissez une méthode associée, En plus de renvoyer le même type de valeur  si ce nest le vide void, assurez vous que la méthode prend le même nombre d'arguments. Voici un exemple:

using System;

delegate void dlgSimple();
delegate double Addition(double x, double y);

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

    private static double Plus(double a, double b)
    {
	return a + b;
    }

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

De nouveau, pour associer la méthode, déclarez une variable du type délégué et passez le nom de la méthode au constructeur du délégué. Voici un exemple :

Addition Add = new Addition(Plus);

Notez que seulement le nom de la méthode est passé au délégué. Pour utilisez réellement le délégué, quand vous l'appelez, dans ses parenthèses, fournissez une valeur pour les arguments conforme au type indiqué en déclarant le délégué. Voici un exemple :

using System;

delegate void dlgSimple();
delegate double Addition(double x, double y);

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

    private static double Plus(double a, double b)
    {
	return a + b;
    }

    static int Main()
    {
	double Value1 = 248.66, Value2 = 50.26, Result;
	dlgSimple Announce = new dlgSimple(Welcome);
	Addition  Add = new Addition(Plus);

	Result = Add(Value1, Value2);

	Announce();
	Console.WriteLine("\n{0} + {1} = {2}", Value1, Value2, Result);

	return 0;
    }
}

Ceci produirait :

Welcome to the Wonderful World of C# Programming!

248.66 + 50.26 = 298.92

En utilisant des délégués, une méthode peut être indirectement passée comme argument à une autre méthode. Pour procéder, déclarez d'abord le délégué nécessaire. Voici un exemple d'un tel délégué :

using System;

namespace GeometricFormulas
{
    public delegate double Squared(double x);

    public class Circle
    {
	private double _radius;

	public double Radius
	{
	    get { return _radius; }

	    set  { _radius = value; }
	}
    }
}

Un délégué peut être passé comme argument à une méthode. Un tel argument serait utilisé comme si c'était une méthode elle-même. Ceci signifie que, une fois accédé dans le corps de la méthode, le nom du délégué doit être accompagné des parenthèses et si le délégué prend un argument ou l'argument, les arguments doivent être fournis dans les parenthèses du délégué appelé. Voici un exemple :

using System;

namespace GeometricFormulas
{
	public delegate double Squared(double x);

	public class Circle
	{
		private double _radius;

		public double Radius
		{
			get { return _radius; }

			set	{ _radius = value; }
		}

		public double Area(Squared sqd)
		{
			return sqd(_radius) * Math.PI;
		}
	}
}

Après la déclaration d'un délégué, Rappelez vous de définir une méthode qui met en application le comportement nécessaire de ce délégué. Voici un exemple :

using System;

namespace GeometricFormulas
{
	public delegate double Squared(double x);

	public class Circle
	{
		private double _radius;

		public static double ValueTimesValue(double Value)
		{
			return Value * Value;
		}
	}
}

Vous pouvez également définir la méthode associée dans une autre classe, pas nécessairement dans la classe où le délégué serait nécessaire. Une fois la méthode qui met en application le délégué est connue, vous pouvez utiliser le délégué comme vous voulez. Pour ce faire, vous pouvez déclarer une variable du type de ce délégué et passer la méthode mise en application à son constructeur. Voici un exemple :

using System;

namespace GeometricFormulas
{
	public delegate double Squared(double x);

	public class Circle
	{
		private double _radius;


		public static double ValueTimesValue(double Value)
		{
			return Value * Value;
		}

		public double Area(Squared sqd)
		{
			return sqd(_radius) * Math.PI;
		}

		public void CircleCharacteristics()
		{
			Squared Sq = new Squared(ValueTimesValue);
		}
	}

}

Cette déclaration donne la vie au délégué et peut alors être utilisée comme nous l'avons procédé avec les délégués jusqu'ici.

Voici un exemple :

using System;

namespace GeometricFormulas
{
	public delegate double Twice(double x);
	public delegate double Squared(double x);

	public class Circle
	{
		private double _radius;

		public static double TwoTimes(double Value)
		{
			return Value * 2;
		}

		public static double ValueTimesValue(double Value)
		{
			return Value * Value;
		}

		public double Radius
		{
			get { return _radius; }

			set	{ _radius = value; }
		}

		public Circle()
		{
			_radius = 0;
		}

		public Circle(double r)
		{
			_radius = r;
		}

		public double Diameter(double rad)
		{
			return rad * 2;
		}

		public double Circumference(Twice FDiam)
		{
			double Circf;
		
			Circf = FDiam(_radius);
			return Circf * Math.PI;
		}

		public double Area(Squared sqd)
		{
			return sqd(_radius) * Math.PI;
		}

		public void CircleCharacteristics()
		{
			Squared Sq = new Squared(ValueTimesValue);
			Twice   Tw = new Twice(TwoTimes);

			Console.WriteLine("Circle  Characteristics");
			Console.WriteLine("Radius:        {0}", Radius);
			Console.WriteLine("Diameter:      {0}", Diameter(_radius));
			Console.WriteLine("Circumference: {0}", Circumference(Tw));
			Console.WriteLine("Area:          {0}\n", Area(Sq));
		}
	}

	class Exercise
	{
		static int Main()
		{
			Circle Round = new Circle(25.58);

			Round.CircleCharacteristics();
			return 0;
		}
	}
}

Ceci produirait :

Circle  Characteristics
Radius:        25.58
Diameter:      51.16
Circumference: 160.723880157654
Area:          2055.65842721639