Der C#-Objektsender ist eines der Argumente und ein Parameter zum Erstellen der Referenz des Objekts, das für die Ereignisse ausgelöst wurde, die verwendet werden, um dem Handler auf die Zuordnung des richtigen Objekts zu antworten, jedoch im Falle statischer Parameter Bei Ereignissen oder Ereignissen ist der Wert null. Mithilfe der EventArgs-Klasse können wir die Parameter an die Methode übergeben. Daher werden die EventArgs-Klasse und ihr Konstruktor zum Erstellen der Objekte verwendet. Diese Klassen stammen aus den Standard-Frameworks, sodass sie überall dort verwendet werden, wo sie verwendet werden Benutzeranforderungen an die Anwendung.
Syntax:
In C# ist ein Objekt die Stamm- und übergeordnete Klasse der Anwendung; Wenn wir die spezifischen Klassenmethoden, Schlüsselwörter und Variablen verwenden möchten, um Objekte für die spezifische Klasse zu erstellen, wird dies erreicht.
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-----
}
}Die oben genannten Codes sind die grundlegende Syntax für die Nutzung und den Zugriff auf die Klassenobjekte von einem Ort zum anderen. Es sieht aus wie EventArgs und der Handler, der die erstellten Objekte verarbeitet.
Im allgemeinen Objekt ist der Absender einer der Parameter in der C#-Sprache und wird außerdem zum Erstellen der Instanz des Objekts verwendet, die durch die spezifischen Ereignisse in der Anwendung ausgelöst wird. Dieses Ereignis wird mithilfe des Eventhandler-Mechanismus verarbeitet, der hauptsächlich für die Erstellung der Objekte zuständig ist. Wenn wir jedoch einige Schlüsselwörter wie „statisch“ und „dynamisch“ verwenden, variieren die Werte voneinander. Wenn wir statische Ereignisse verwenden, sind die Parameterwerte immer null. Die Ereignishandler sind eine der Methoden, die am häufigsten zum Ausführen der Objekte basierend auf der Clientanforderung verwendet werden können. Anschließend wird die Antwort auf die spezifischen Ereignisse geworfen, die in der Anwendung auftreten.
Aufgrund der Objektsenderreferenz wird das Ereignis ausgelöst und ausgeführt, sodass der Absender eine der Hauptsteuerungen ist, die zum Aktivieren der Ereignisse verwendet werden können. In der Benutzeroberfläche ist die Schaltfläche eines der Ereignisse und wird hauptsächlich zum Ausführen von Benutzeroperationen und -aktionen im Backend verwendet. Sobald wir auf die Absenderschaltfläche geklickt haben, wird das Ereignis ausgelöst und Vorgänge werden basierend auf den Benutzeranforderungen ausgeführt. Die Daten des Kunden werden sowohl vom Front-End als auch vom Backend aus validiert.
Unten sind die verschiedenen Beispiele für C#-Objektsender:
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);
}
}Ausgabe:
Im ersten Beispiel haben wir denselben Objektsender- und Event-Handler-Mechanismus zum Erstellen und Senden der Objektreferenz verwendet und mit den Standardmethoden verwendet. Wir können die beiden verschiedenen Ereignisse erstellen und mithilfe ihrer Instanz diese Ereignisse aufrufen und die separate Instanz erstellen, die auf der Ausgabekonsole gedruckt wird.
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");
}
}Ausgabe:
Im zweiten Beispiel haben wir einige zusätzliche Standardmethoden wie OnChanged(), Add(), Clear(); Dies sind die vordefinierten Methoden zum Bereinigen der Garbage Collections, wann immer das Objekt erstellt wird, und zum Zuweisen des Speichers, wenn wir den unerwünschten Verweis entfernen möchten. Mit den Standardmethoden clear(), remove() können wir ihn entfernen.
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");
}
}Ausgabe:
Im letzten Beispiel haben wir die Event-Handler-Klasse und ihre Standardschlüsselwörter wie „add“ und „remove“ zum Hinzufügen und Entfernen der Werte aus dem Speicher verwendet. Diese Werte werden von jeder Klasseninstanz und ihren Methoden berechnet und aufgerufen. Wenn die Methode über die Parameter verfügt, ruft sie diese mit Hilfe ihrer Instanz auf und übergibt sie.
C# verfügt über so viele vordefinierte Schlüsselwörter, Methoden und deren Attribute für jeden Satz von Elementen, dass es über eine eigene Syntax und Regeln für die anspruchsvollere Verwendung des Codes verfügt und Duplikate sowie Coderedundanz vermeidet. Wie dieses Objekt ist auch der Absender einer der Parameter, die es an die Methoden für deren Klassenreferenz und Verwendung übergeben.
Das obige ist der detaillierte Inhalt vonC#-Objektsender. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
