Wenn wir Remoting-Programme oder andere Anwendungen schreiben, müssen wir uns zwangsläufig mit Threads befassen. Mit .Net können wir problemlos Threads erstellen, aber die Methoden zum Erstellen und Starten von Threads bieten keine offensichtlichen Parameter wenn ich einen Thread verwenden möchte, um eine Methode mit Parametern in einer Klasse zu starten? Im Folgenden finden Sie eine kurze Einführung in die Verwendung des von .NET bereitgestellten umfangreichen Frameworks zur Implementierung dieser Funktion. Um den gesamten Prozess detailliert darzustellen, habe ich die folgende .NET-Klasse erstellt, die auch Träger der Thread-Startmethode ist. Die Klasse sieht folgendermaßen aus:
using System;
Namespace WindowsApplication1
{
/// <summary>
/// Zusammenfassende Beschreibung für UrlFetcher
/// </summary>
öffentliche Klasse MyClass{
// für Methode 1
private string _parameter;
public MyClass(string parameter){
this._parameter = parameter;
}
public void MyMethod1(){
if(this._parameter!=null){
// etwas tun
Console.Write(this._parameter );
}
}
// für Methode 2
public MyClass(){}
// Diese Methode ist privat, kann aber öffentlich oder anders
privat sein void MyMethod2(string parameter){
// etwas tun
Console.Write(parameter }//
Weil der Delegat WaitCallback ist
;
Parametertyp ist Objekt
// Ich werde es in einen String konvertieren.
public void MyMethod2(object parameter){
this.MyMethod2((string)parameter
}
// für Methode 3
öffentlicher String MyMethod3(string Parameter){
return „Der Parameterwert ist:“+parameter
}
// für Mutil-Parameter übergebener
öffentlicher String MyMutilParameters(string param1,string param2){
return "Das Verbindungsergebnis von Parameter 1 und Parameter 2 ist: "+param1+param2
}
}
}
Hehe, mein Englisch ist nicht gut. Bitte verzeihen Sie mir die schlechte Schreibweise der Kommentare (denn ich hoffe, dass es Ihre Lektüre nicht beeinträchtigt). Ich halte es für notwendig, kurz auf den Inhalt der oben genannten Klasse einzugehen. Erstens enthält es zwei Konstruktoren, einen mit Parametern und einen ohne (dies ist absichtlich angeordnet). Ich denke, Sie werden es anhand der Namen anderer Methoden in der Klasse erraten. Ich werde drei Methoden zum Übergeben von Parametern vorstellen und sie dann einzeln vorstellen. Schauen wir uns zunächst an, wie ein Thread gestartet wird. Zuerst können wir eine Instanz des ThreadStart-Delegaten instanziieren, diese Instanz dann als Parameter für ein neues Thread-Objekt verwenden und schließlich den Thread starten Weitere Informationen finden Sie im Thread-Abschnitt der MSDN-Dokumentation.
Um unsere Ergebnisse zu testen, habe ich ein WinForm-Projekt erstellt, das ein Formular und 4 Schaltflächen enthält. Wenn Sie den gesamten Quellcode benötigen, senden Sie ihn bitte per E-Mail an [email protected] . Im Folgenden finden Sie eine detaillierte Beschreibung jeder Methode.
1. Verwenden Sie einen Konstruktor, um Parameter zu übergeben
. Wie wir alle wissen, können wir einen Konstruktor mit Parametern verwenden, um ein Objekt zu erstellen. In diesem Fall können wir den Konstruktor verwenden, um zuerst die zu verwendenden Parameterwerte zu übergeben Interne Variablen im Objekt, und verwenden Sie dann eine Parameter-Methode ohne Parameter, um diesen Parameter zu verwenden (so tun, als wäre er ein Parameter). Um es einfach auszudrücken: Deklarieren Sie eine Variable in der Klasse speziell zum Speichern der von der Funktion benötigten Parameter, und die Funktion wird zu einer parameterlosen Form. Das größte Problem bei dieser Methode besteht darin, dass sie die Kapselung zerstört. Obwohl wir nicht direkt auf diese Variablen zugreifen können, bestehen immer versteckte Gefahren (oder es spielt keine Rolle, ob es unangenehm aussieht). Der folgende Codeausschnitt enthält Einzelheiten zur Verwendung dieser Methode zum Übergeben von Parametern. Dies ist auch der Click-Code für eine der vier oben genannten Schaltflächen (Button1). Um Parameter zu übergeben, habe ich in WinForm global eine Variable wie folgt definiert:
// Dies ist der Wert des Parameters
private string myParameter = "ParameterValuen"
Das Schaltflächenereignis lautet wie folgt:
// Parameter wurden per Konstrukt
privat
an den Thread übergebenvoid button1_Click( object sender, System.EventArgs e) {
MyClass instance = new MyClass(myParameter);
new Thread (new ThreadStart(instance.MyMethod1)).Start();
}
Wie oben erwähnt, verwenden wir den Konstruktor, um Parameter zu übergeben Wenn wir die Klasse Go aufrufen und dann einen Thread mit der oben genannten Methode starten, können wir das Ausführungsergebnis von MyMethod1 im Ausgabefenster sehen, nachdem wir das Programm ausgeführt haben (Sie können auch eine TextBox oder etwas anderes verwenden, um es direkt auf der WinForm anzuzeigen): Parameterwert. Schauen Sie sich einfach den Funktionskörper an und Sie werden sehen, dass das Ergebnis korrekt ist. Ist es nicht ganz einfach?
2. Verwenden Sie ThreadPool, um die Parameterübertragung zu realisieren.
Wir können uns zunächst ansehen, wie MSDN einen Threadpool bereitstellt, der zum Posten von Arbeitselementen, zum Verarbeiten asynchroner E/A, zum Warten im Namen anderer Threads und zum Verarbeiten von Zeitgebern verwendet werden kann. Sehen Sie sich die Methodensammlung an, eine davon heißt: QueueUserWorkItem. Ausführliche Informationen zu dieser Klasse und dieser Methode finden Sie in der MSDN-Hilfe. Was hier beachtet werden muss, sind die Parameter der QueueUserWorkItem-Methode. Der Parameter WaitCallback ist der Parameter, der von der Delegate-Instanz benötigt wird (nachdem sie mit einer Funktion instanziiert wurde). des Objekttyps. Weitere Informationen finden Sie im folgenden Code.
// Parameter von ThreadPool an Thread übergeben
private void button2_Click(object sender, System.EventArgs e) {
MyClass
example = new MyClass(
)
;
von QueueUserWorkItem Die Parameter sind vom Objekttyp, daher müssen wir in MyClass zwei Versionen mit geänderter Größe von MyMethod2 definieren, um die Parameter der Methode zu erfüllen. Ebenso haben wir den Parameter myParameter übergeben und das Programm ausgeführt. Wenn wir auf Button2 klicken, wird das Ergebnis der Ausführung von myParameter durch MyMethod2 im Ausgabefenster angezeigt.
3. Als nächstes verwenden Sie die asynchrone Delegation, um die Parameterübertragung zu realisieren
. Ausführliche Informationen zur Delegation finden Sie in MSDN, das oben sehr detailliert beschrieben wird. Wir werden hier die Methoden BeginInvoke und EndInvoke verwenden. Zuerst geben wir die Methode zum Übergeben eines Parameters wie folgt an:
// Übergebener Parameter durch asynchronen Delegate
-Delegatenstring MyMethod3Delegate(string-Parameter);
private void button3_Click(object sender, System.EventArgs e) {
MyClass-Instanz = new
MyMethod3Delegate
myMethod3
= neuer MyMethod3Delegate(
Instanz.Mymethod3
);
(MyMethod3Delegate
)
async.AsyncDelegate;
Console.WriteLine ("Rückgabewert des Funktionsaufrufs: {0}n", DelegateInstance.EndInvoke(result));
Um
den Delegaten zu verwenden, deklarieren wir zunächst einen Delegaten von MyMethod3Delegate, der einen Parameter angibt und Rückgabewert Funktionen, bei denen es sich um Zeichenfolgen handelt, sind zulässig, daher definieren wir eine MyMethod3-Methode in MyClass. Die Struktur dieser Funktion entspricht dem obigen Delegaten, sodass wir diese Methode verwenden können, um einen Delegaten zu instanziieren, wenn auf Button3 geklickt wird, und dann diese Methode asynchron aufrufen. Um das Rückgabeergebnis zu erhalten, haben wir die Methode AfterMyMothod3 geschrieben, um die anzuzeigen Ergebnisse der Funktionsausführung. Führen Sie das Programm aus und klicken Sie auf Button3, um zu sehen, dass die in Ausgabe ausgegebenen Ergebnisse die Ergebnisse der MyMethod3-Ausführung mit Parametern sind. Abschließend gebe ich eine Methode zur Übergabe mehrerer Parameter an. Mein Beispiel ist die Übergabe von zwei Parametern. Der Code lautet wie folgt:
// mutil-parameters übergebenen
Delegaten string MyMutilParamsDelegate(string parameter1,string parameter2);
private void button4_Click(object sender, System.EventArgs e) {
MyMutilParamsDelegate
mutilParams = new MyMutilParamsDelegate( Instanz.MyMutilParameters);
mutilParams.BeginInvoke("param1","params2",new AsyncCallback(AfterMutilParams),null
}
public void AfterMutilParams(IAsyncResult result){
AsyncResult async = (AsyncResult) result;
MyMutilParamsDelegate Delegate = (MyMutilParamsDelegate) async.AsyncDelegate
("Multiparameter-Funktionsaufruf gibt Ergebnis zurück: {0}n", DelegateInstance.EndInvoke( result ));
}
Aus Platzgründen wird der Code nicht im Detail erläutert. Bitte korrigieren Sie mich, wenn es Ungenauigkeiten gibt. Vielen Dank fürs Lesen! Kontaktinformationen: [email protected] CSDN-Forum-ID: cuike519
Referenzdokumente: