C#-Lerntagebuch 19----Referenztyp des Delegattyps (Delegate).

Die Bedeutung des Delegate-Typs wurde im Vorwort zum Referenztyp eingeführt (zum Anzeigen klicken). Ein Delegat ist eine Klasse, die Methoden definiert. Der Typ ermöglicht die Übergabe der Methode als Parameter eines anderen Methode. Um es ganz klar auszudrücken: Die Methode kann als Parameter übergeben werden. Alle Delegaten (Delegate) werden von der System.Delegate-Klasse abgeleitet.

(Ich scheine es nicht zu verstehen) Nehmen wir einen Vergleich: Roommate HC555 ist ein LoL-Enthusiast und kauft gerne auf Taobao ein. Der Kurier rief ihn an, um ihn abzuholen Lieferung, das Ärgerlichste am Spielen ist das, also hat er mich gebeten, die Expresslieferung für ihn zurückzunehmen. Zu diesem Zeitpunkt betrachten wir den Mitbewohner als eine (Mitbewohner-)Klasse, und die Annahme der Expresslieferung ist eine Methode in der Klasse (takepackage()), und ich bin ein von Delegate instanziiertes Objekt (ein Objekt, das Methoden tragen kann), das die Methode zum Abholen der Expresszustellung von meinem Mitbewohner „trägt“.

Deklaration eines Delegaten:

Die Deklaration eines Delegaten bestimmt die Methoden, auf die der Delegat verweisen kann. Ein Delegat kann auf eine Methode mit derselben Bezeichnung verweisen.

Deklarieren Sie beispielsweise einen Delegaten:

　　　　public delegate int MyDelegate(string str); //string类型的变量就是它的标签

Der obige Delegat kann verwendet werden, um auf jede Methode zu verweisen, die einen einzelnen Zeichenfolgenparameter akzeptiert und eine Variable vom Typ int zurückgibt.

Instanziieren Sie einen Delegaten:

Der Delegat ist der Typ der Methode. Sobald der Delegatentyp deklariert ist, muss das Delegatobjekt mit dem neuen erstellt werden Schlüsselwort, und es muss mit dem neuen Schlüsselwort erstellt werden, das sich auf eine bestimmte Methode bezieht. Beim Erstellen eines Delegaten werden Methoden als Variablen, jedoch ohne Parameter, an die neue Anweisung übergeben. Zum Beispiel:

  public delegate int MyDelegate(string str);  //委托的声明
           .....   
           public static int Add(string s);   //定义的一个方法
         .....   
         MyDelegate my = new MyDelegate(Add) ;  //实例化一个委托，其实就是实例化一个对象

Codebeispiel:

Zurück zur Geschichte der Abholung der Expresslieferung, wir wandeln diese Geschichte in Code um:

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{   
    public delegate void MyDelegate(string str);    //委托的声明  
  
    class roomfriend  //定义室友这个类  
    {   
        public static void takepackage(string name)  //定义一个取快递的方法  
        {  
           Console.WriteLine("我叫 {0} 这是一个取快递方法",name);  
            
        }  
    }  
    class program  
    {  
        static void Main(string[] args)  
        {  
            MyDelegate myd = new MyDelegate(roomfriend.takepackage); //实例化一个委托“我”携带一个方法（将方法当参数传入）  
            myd("HC555");   //由我实现室友的方法，实际是室友的方法当参数传给了我  
        }  
    }  
}

Das Ergebnis ist folgendes:

Als ich nach Abholung der Expresslieferung ins Wohnheim zurückkehrte, rief mich meine Mitbewohnerin an und sagte, er sei hungrig und habe mich gebeten, etwas zu essen zu kaufen, als ich am Supermarkt vorbeikam. Ganz im Sinne von Lei Feng stimmte ich zu ... „Etwas kaufen“ kann hier auch als Methode in „roomfriend“ und „ich“ angesehen werden. auch „tragen“ Es gibt eine Methode von ihm. Verwenden Sie in C# „+=", um die Zusammenführungsmethoden nacheinander zu verbinden und sie beim Aufruf nacheinander auszugeben.

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{   
    public delegate void MyDelegate(string str);    //委托的声明  
  
    class roomfriend  //定义室友这个类  
    {   
        public static void takepackage(string name)  //定义一个取快递的方法  
        {  
           Console.WriteLine("我叫 {0} 这是一个取快递方法",name);  
            
        }  
        public static void shopping(string name)   //定义一个买东西的方法  
        {  
            Console.WriteLine("我叫 {0}  这是一个买东西的方法",name);  
        }  
      
    }  
    class program  
    {  
        static void Main(string[] args)  
        {  
            MyDelegate myd = new MyDelegate(roomfriend.takepackage); //实例化一个委托“我”携带一个方法（将方法当参数传入）  
            
            myd += roomfriend.shopping;    // += 合并运算顺序执行方法   
            myd("HC555");  
        }  
    }  
}

Die Ergebnisse sind wie folgt:

(Leider! Hast du den Express abgeholt? Gibt es noch etwas... 0.0)

Oben verwenden wir „+=", um die Methode zu verbinden, wann immer wir wollen Um eine Methode abzubrechen, können wir natürlich „-=" verwenden, um die Verbindung mit der „I“-tragenden Beziehung abzubrechen. Im obigen Code müssen wir also nur myd -= roomfriend.takepackage // hinzufügen und es unter += setzen, damit das Die Express-Methode wird nicht erneut aufgerufen.

Ich kaufte ein paar Schachteln Kekse im Supermarkt und mein Telefon klingelte erneut. Er sagte mir, dass das Paket für seine Freundin sei und bat mich, es auszuliefern Zu ihm. In der Vergangenheit haben gute Leute daran festgehalten, und ich habe dem zugestimmt. . Als sie ihrer Freundin einen Kurierdienst überbrachte, war sie in Eile und nahm mir schnell alle meine Sachen weg, einschließlich der Schachteln mit Keksen. . Dann lachte ich und kehrte glücklich in den Schlafsaal zurück ... Hier definieren wir eine andere (Freundin-)Klasse, die eine Methode zum Akzeptieren (Akzeptieren) hat, und ich (Delegieren) wird als Parameter der Methode verwendet > Definitionsmethode: public static void Accept(string name,MyDelegate pack); Wenn Sie sich einen Delegaten als eine Box vorstellen, dann ist diese Box voller Methoden mit demselben Parametertyp. Wir vergleichen das MyDelegate-Paket mit dem String-Namen, der eine Variable vom Typ String ist, und das Pack kann als Variable vom Typ MyDelegate bezeichnet werden.

Das Ergebnis ist das gleiche

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace Test  
{   
    public delegate void MyDelegate(string str);    //委托的声明  
  
    class roomfriend  //定义室友这个类  
    {   
        public static void takepackage(string name)  //定义一个取快递的方法  
        {  
           Console.WriteLine("我叫 {0} 这是一个取快递方法",name);  
            
        }  
        public static void shopping(string name)   //定义一个买东西的方法  
        {  
            Console.WriteLine("我叫 {0}  这是一个买东西的方法",name);  
        }  
      
    }  
    class girlfriend  //定义一个girlfriend 类  
    {  
        public static void accept(string name,MyDelegate package) //定义一个accept方法 将委托作为参数传入     
          {  
        package(name);  
    }  
}  
class program  
{  
    static void Main(string[] args)  
    {  
        MyDelegate myd = new MyDelegate(roomfriend.takepackage); //实例化一个委托“我”携带一个方法（将方法当参数传入）  
        
        myd += roomfriend.shopping;    // += 合并运算顺序执行方法   
  
        girlfriend.accept("HC555", myd);  
    }  
}

Reflexion:

In dem Beispiel, das ich oben angegeben habe, wird „Mitbewohner“ oder „Freundin des Mitbewohners“ als Klasse betrachtet. Wenn ich die Methode aufrufe, verwende ich den Typnamen „Methodenname“, wenn ich ein instanziiertes Objekt verwende, übergebe ich den Objektnamen . Methodenname Referenzmethode zur Übergabe des Delegaten:

roomfriend myfriend = new roomfriend(); // Instanziiere den Roommate in ein Objekt

MyDelegate myd = new MyDelegate(myfriend.tackpackage ; Es stellt sich heraus, dass takepackage im Code zwar als öffentlicher Zugriff deklariert wurde, es jedoch dennoch in ein privates Feld kompiliert wird. Dies hängt mit der Statik zusammen, die wir bei der Definition der Methode verwendet haben (mehr dazu später). kann sein Dies ist möglich;

Das Obige ist der Inhalt des C#-Lerntagebuchs 19----Referenztyp Delegat (Delegate) Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www. php.cn)!