DELEGATE

Type safe function pointer

 Delegate

Delegate: pointeur de fonction sécurisé. Autrement dit, Delegate

contient une référence à une méthode (MaMethodeName) afin d’appeler
(MaMethodeName) pour exécution.
 Pourquoi on utilise Delegate ?
Afin de faire appel à des méthodes en C # il existe deux manières différentes.
• En utilisant une instanciation de class si la méthode n’est pas « static ».
• En utilisant le nom de la class si la méthode est « static ».
Example:
public class StaticAndPublicExample
{ public int mySum(int a, int b)
{ return (a + b); }
public static void chaine(string str)
{Console.WriteLine(str);}

static void Main(string[] args)

{StaticAndPublicExample sp = new StaticAndPublicExample();

int resSum = sp.mySum(10, 20);

Console.WriteLine(resSum);

StaticAndPublicExample.chaine("hello");
Console.ReadLine();
}
}
 Example Public/Static methods
namespace ConsoleApp1
{ internal class DelegateTest
{
public int sum(int a, int b)
{ return (a + b);}
public static void chaine1(string str)
{Console.WriteLine(str);}
static void Main(string[] args)
{DelegateTest dt = new DelegateTest();
int resSum = dt.sum(10,20);
Console.WriteLine(resSum);
DelegateTest.chaine1("hello");
Console.ReadLine();}
}
}
 Pourquoi on utilise Delegate ?

ØOn utilise delegate pour appeler touts types de méthodes que se soit
static ou public.
ØOn utilise delegate parce que c’est un moyen sécuriser de faire appel
à des méthodes.
 Comment on utilise Delegate
Afin d’appeler une méthode en utilisant delegate, trois étapes à suivre:

1) Définition de Delegate:
[<modifier>] delegate void|Type <delagatefunctName>([<parameter list>])

2) Instanciation de Delegate:
on passe le nom de la fonction a appeler comme paramètre à delegate (delegate détient une référence
de la méthode).
ü Si la méthode est public:
<delagatefunctName> <InstanceName>=new <delagatefunctName> <classInstanceName.funcName>
üSi la méthode est static
<delagatefunctName> <InstanceName>=new <delagatefunctName> <funcName>

3) Appelation de Delegate:
soit un appel en utilisant le nom d’objet avec les paramettre(methode habituelle) soit on utilise
<objectName>. Invoke ([<parameter list>])
 Comment définir Delegate:Application
1) définir delegate: [<modifier>] delegate void|Type <functionName>([<parameter list>])
Ø Example
public delegate int sumDelegate(int x, int y)
public int mySum(int a, int b)
public delegate void chaineDelegate(string myStr)
public static void chaine1(string str)

Il faut définir delegate sous NameSpace, on peut aussi la définir sous la class sa devient nested méthode
(ce n’est pas conseiller).

2) Instanciation de delegate: On passe le nom de la fonction a appeler comme paramètre à

delegate (delegate détient une référence de la méthode)

sumDelegate sumD = new sumDelegate(sp.mySum);

chaineDelegate chainD= new chaineDelegate(chaine);

3) Appelation de delegate:

int resSum = sumD(40, 60);// or sumD.Invoke(40,60)

chainD("hello");// or chainD.Invoke("hello");
•
 Conclusion de cette première étape
On pourra appeler des méthodes en c # soit en utilisant :
• Une instanciation (si la méthode est public)
• Utilisation du nom de la class className.methodName (si la méthode est Static)
• Utilisant delegate (quelque soit la méthode, static ou public)
Les étapes pour Utiliser delegate
• Definition
• Instanciation
• appelation
•
 Multicasting Delegate
delegate on pourra contenir la référence de plusieurs méthodes a la fois .
Les méthodes doivent avoir le même type de retour et le même type de parametre
et soit toutes static ou toutes pubic.
1) On définie une seul delegate pour toutes les méthodes
2) On instancie on utilisant un objet incrementale
Example:
sumDelegate sumD = new sumDelegate(dt.mySum);// sumDelegate sumD = dt.mySum;
On procede comme suite
sumDelegate sumD = dt.mySum;
sumD + = dt.Chaine;
3) Appel de multicast delegate : si les méthodes ont un type de retour, on récupère
juste les données de la dernière méthode invoquée.
Int result= sumD(20,40)

1)
 Anonymous Méthodes

Au lieu, de passer le nom de la méthode à la fonction Delegate, on va

passer un bloc de code comme paramètre à Delegate.
 Anonymous méthode : Application
namespace AnonymousMethod
{
public delegate string chaineDelegate(string myStr)
internal class DelegateTest
{
public static string chaine(string str)
{return "hello" + str + "Students!"; }
static void Main(string[] args)

{//DelegateTest dt = new DelegateTest();as it is static we dont need class

instance

chaineDelegate obj = chaineDelegate (chaine);//we call it directly

string resChaine = obj.Invoke("EMSI"); // equivalent to obj("EMSI");

Console.WriteLine(resChaine);
Console.ReadLine();}
}
}
 Anonymous méthode : Application
namespace AnonymousMethod
{
public delegate string chaineDelegate(string myStr)
internal class DelegateTest
{
static void Main(string[] args)

{chaineDelegate obj = delegate(string str)

{return "hello" + str + "Students!"; }

string resChaine = obj.Invoke("EMSI");

Console.WriteLine(resChaine);
Console.ReadLine();}
}
}
 Conclusion d’Anonymous méthode

• Lors que le volume du code à l’ intérieur d Anonymous méthode n’est

pas trop long max 10 lignes de code
• Parmi les avantage d’ Anonymous methode c’est quelle resuis le
volum de code .
 Lambda Expression
• C’est une expression pour appeler Anonymous méthode d’une manier
plus réduite.
 Anonymous to Lambda Expression
namespace AnonymousMethod
{
public delegate string chaineDelegate(string myStr)
internal class DelegateTest
{
static void Main(string[] args)

{chaineDelegate obj = delegate (string str)

{return "hello" + str + "Students!"; }

string resChaine = obj.Invoke("EMSI");

Console.WriteLine(resChaine);
Console.ReadLine();}
}
}
 Lambda Expression: Application
namespace AnonymousMethod
{
public delegate string chaineDelegate(string myStr)
internal class DelegateTest
{
static void Main(string[] args)

{chaineDelegate obj = (str) =>

{return "hello" + str + "Students!"; }

string resChaine = obj.Invoke("EMSI");

Console.WriteLine(resChaine);
Console.ReadLine();}
}
}
 Génériques Delegate
La définition de delegate n’est pas obligatoire si on utilise les génériques
delegate comme suite :

qFunc : quand la méthode a un type de retour <string, int, ….,doubl>

qAction :quand la méthode n’a pas de type de retour

q
qPredicate :quand la méthode a un type de retour qui est Boolean.
Predicate prend un seul paramètre d’entrer
q
namespace GenericDelegate
{
public delegate double Delegate1(int a,int b,int c)
public delegate void Delegate2(int a,int b,int c)
public delegate bool Delegate3(int a,int b,int c)
internal class DelegateTest
{
public static double addition1(int a,int b,int c)
{return a + b + c; }
public static void addition2(int a,int b,int c)
{Console.WriteLine( a + b + c); }
public static bool addition3(int a)
{ if (a>b=20)
return true;
return false;}
static void Main(string[] args)
{Delegate1 obj1 = (addition1);//we can call it directly
double res1 = obj.Invoke(10,20,30);
Console.WriteLine(res1);
//// 2
Delegate2 obj2 = (addition2);//we can call it directly
obj.Invoke(10,20,30);
//// 3
Delegate3 obj3 = (addition3);//we can call it directly
double res3 = obj.Invoke(10);
Console.WriteLine(res3);
Console.ReadLine();}
}
}
namespace GenericDelegate
{
internal class DelegateTest
{
public static double addition1(int a,int b,int c)
{return a + b + c; }
public static void addition2(int a,int b,int c)
{Console.WriteLine( a + b + c); }
public static bool addition3(int a)
{ if (a>b=20)
return true;
return false;}
static void Main(string[] args)
{Func <int,int,int,double> obj1 = (addition1);
double res1 = obj.Invoke(10,20,30);
Console.WriteLine(res1);
//// 2
Action <int,int,int,> obj2 = (addition2);
obj.Invoke(10,20,30);
//// 3
Predicate<int> obj3 = (addition3);//we can use also func as Func<int,bool>
double res3 = obj.Invoke(10);
Console.WriteLine(res3);
Console.ReadLine();}
}
}
 Génériques Delegate
qFunc : quand la méthode a un type de retour <string,int, double…>
Func<InputType, InputType…..,OutputType>
Func<Int, String…..,double>

qAction :quand la méthode n’a pas de type de retour

Action<InputType, InputType…..>
Action<Int, String…..>
q
qPredicate :quand la méthode a un type de retour Boolean .Predicate prend un seul paramètre
d’entrer
Predicate<InputType>
Predicate<Int>
NB:
Predicate est equivalentFunc<int,bool>
q
Exercice : Consol application
Afin de calculer La surface d’un cylindre et le volume du cylindre.
1)Utiliser delagate
2) Utiliser Anonymous
3) Utiliser lambda expression
Note
le volume d'un cylindre de hauteur h = 5 cm et de rayon de base r = 4 cm.
q On détermine d'abord l'aire B de sa base en cm2 :
B = π × r × r.
B = 3,14 × 4 × 4 = 50,24
q On en déduit le volume V du cylindre en cm3 :
V = B × h.
V = 50,24 × 5 = 251,2
La surface d’un cylindre:
q A = 2 π r² + 2 π r h
Reference
• https://www.toutcalculer.com/geometrie/volume-surface-
cylindre.php