Expéditeur d'objet C#

L'expéditeur de l'objet C# est l'un des arguments, et c'est un paramètre pour créer la référence de l'objet qui a été déclenché pour les événements qui sont utilisés pour répondre au gestionnaire pour mapper l'objet correct mais en cas de paramètres statiques ou des événements, la valeur sera nulle à l'aide de la classe EventArgs, nous pouvons transmettre les paramètres à la méthode, donc la classe EventArgs et son constructeur sont utilisés pour créer les objets que ces classes proviennent des frameworks par défaut afin qu'elles les utilisent partout où le besoins des utilisateurs sur l'application.

Syntaxe :         

En C#, un objet est la classe racine et parent de l'application ; lorsque nous souhaitons utiliser les méthodes de classe, les mots-clés et les variables spécifiques pour créer des objets pour la classe spécifique, nous y parviendrons.

using System;
using System. Web;
Access modifiers class class name {
Access modifiers return type function_name(object reference name(sender), EventArgs reference name)
{
--some C# code logics depends upon the user requirement-----
}
}

Les codes ci-dessus constituent la syntaxe de base pour utiliser et accéder aux objets de classe d'un endroit à un autre. Cela ressemble à EventArgs et au gestionnaire pour gérer les objets créés.

Comment fonctionne l'expéditeur d'objets en C# ?

Dans l'objet général, l'expéditeur est l'un des paramètres du langage C#, et également, il est utilisé pour créer l'instance de l'objet, qui est déclenchée par les événements spécifiques sur l'application. Cet événement est géré à l'aide du mécanisme Eventhandler qui est principalement géré et responsable de la création des objets. Mais lorsque nous utilisons certains mots-clés comme statique, dynamique, les valeurs varient les unes des autres si nous utilisons des événements statiques, les valeurs des paramètres sont toujours nulles. Les gestionnaires d'événements sont l'une des méthodes les plus utilisées pour exécuter les objets en fonction de la demande du client ; ensuite, la réponse sera lancée sur les événements spécifiques qui se produiront sur l'application.

En raison de la référence de l'expéditeur de l'objet, l'événement sera déclenché et exécuté, l'expéditeur est donc l'un des principaux contrôles pouvant être utilisé pour activer les événements. Dans l'interface utilisateur, le bouton est l'un des événements et est principalement utilisé pour effectuer les opérations et actions de l'utilisateur sur le backend. Une fois que nous avons cliqué sur le bouton de l'expéditeur, l'événement sera déclenché et les opérations seront effectuées en fonction des besoins de l'utilisateur ; les données du client seront validées à la fois depuis le front-end et le back-end.

Exemples

Voici les différents exemples d'expéditeur d'objet C# :

Exemple n°1

using System;
public delegate void demo(object snd, eventargs er);
public delegate void demo1(object snd, eventargs er);
public delegate void demo2(object snd, eventargs er);
class examp
{
public const string first = "Welcome To My Domain";
public void meth1(object snd, eventargs er)
{
Console.WriteLine("Thank you user your first example program is started ", er.first);
}
public void meth2(object snd, eventargs er)
{
Console.WriteLine("Your code is currently debugged and in-progress", er.first);
}
public void meth3(object snd, eventargs er)
{
Console.WriteLine("Your code is successfully completed", er.first);
}
public examp(examp1 exm)
{
demo d1 = new demo(meth1);
demo1 d2 = new demo1(meth2);
demo2 d3 = new demo2(meth3);
exm.vars1 += d1;
exm.vars2 += d2;
exm.vars3 += d3;
}
}
class examp1
{
public event demo vars1;
public event demo1 vars2;
public event demo2 vars3;
public void third(eventargs er)
{
if (vars1 != null)
{
vars1(this, er);
}
}
public void four(eventargs er)
{
if (vars2 != null)
{
vars2(this, er);
}
}
public void five(eventargs er)
{
if (vars3 != null)
{
vars3(this, er);
}
}
}
public class eventargs : EventArgs
{
public string first;
}
public class second
{
private void seven(object snd, EventArgs er)
{
Console.WriteLine("Welcome To My Domain, please add your details");
}
public static void Main()
{
examp1 exm = new examp1();
examp exam = new examp(exm);
second s= new second();
eventargs e1 = new eventargs();
eventargs e2 = new eventargs();
e1.first = "Your first event is started and triggered";
e2.first = "Your second event is started and triggered";
s.seven("Welcome To My Domain, Thank you users ",e1);
exm.third(e1);
exm.four(e2);
}
}

Sortie :

Dans le premier exemple, nous avons utilisé le même mécanisme d'expéditeur d'objet et de gestionnaire d'événements pour créer et envoyer la référence d'objet et utilisé avec les méthodes par défaut. Nous pouvons créer les deux événements différents, et en utilisant leur instance, nous pouvons appeler ces événements et créer l'instance distincte imprimée sur la console de sortie.

Exemple n°2

using System;
using System.Collections;
public delegate void EventHandler(object snd, EventArgs er);
public class first: ArrayList
{
public event EventHandler vars;
public virtual void OnChanged(EventArgs er)
{
if (vars != null) vars(this, er);
Console.WriteLine("Thanks for your input and your values are validated");
}
public override int Add(Object ob)
{
int fr = base.Add(ob);
OnChanged(EventArgs.Empty);
Console.WriteLine("Your input is added and checking with our backend validationonce completed will get back to you.");
return fr;
}
public override void Clear()
{
base.Clear();
OnChanged(EventArgs.Empty);
Console.WriteLine("Thanks for your second Example your input is validated and cleaned by the browser end");
}
public override object this[int ind]
{
set
{
base[ind] = value;
OnChanged(EventArgs.Empty);
}
}
static void Main(string[] args)
{
first fr = new first();
Console.WriteLine(fr.Add(736));
Console.WriteLine("Thanks for your second Example");
}
}

Sortie :

Dans le deuxième exemple, nous avons utilisé des méthodes par défaut supplémentaires comme OnChanged(), Add(), Clear(); ce sont les méthodes prédéfinies pour nettoyer les garbage collection chaque fois que l'objet est créé et allouer de la mémoire si nous voulons supprimer la référence indésirable en utilisant les méthodes par défaut clear(), remove() nous pouvons la supprimer.

Exemple #3

using System;
public class examp1
{
public event EventHandler evnts
{
add
{
Console.WriteLine("Welcome To My DOmain Your third Example Started");
}
remove
{
Console.WriteLine("Please provide your inputs");
}
}
}
public class examp
{
public void demo()
{
examp1 emp = new examp1();
emp.evnts += third;
emp.evnts -= third;
}
public void third(object snd, EventArgs er)
{
}
public static void Main(string[] args)
{
examp examp = new examp();
examp.demo();
Console.ReadKey();
Console.WriteLine("Your examples are started and executed successfully");
}
}

Sortie :

Dans le dernier exemple, nous avons utilisé la classe des gestionnaires d'événements et ses mots-clés par défaut comme add et delete pour ajouter et supprimer les valeurs de la mémoire. Ces valeurs sont calculées et appelées par chaque instance de classe et leurs méthodes. Si la méthode a les paramètres, elle l'appellera et la transmettra à l'aide de son instance.

Règles et règlements pour l'expéditeur d'objets

1. L'expéditeur de l'objet doit contenir les EventArgs avec des instances ; alors, seul l'expéditeur de l'objet sera exécuté avec ses activités d'utilisateur.
2. Dans les applications des grandes entreprises, la création et l'allocation des objets prendront plus de temps, et l'envoi de leur référence prend également plus de temps.
3. En utilisant la synchronisation, cela évite le blocage dans les threads du processus.

Conclusion

C# a tellement de mots-clés, de méthodes et de leurs attributs prédéfinis pour chaque ensemble d'éléments qu'il a sa propre syntaxe et ses propres règles pour utiliser le code de manière plus sophistiquée et évite les doublons et la redondance du code. Comme cet objet, l'expéditeur est également l'un des paramètres qui le transmettent aux méthodes pour leur référence de classe et leurs utilisations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!