Lorsque nous écrivons des programmes Remoting ou d'autres applications, nous devons inévitablement gérer des threads. .Net nous permet de créer facilement un thread, mais les méthodes qu'il fournit pour créer des threads et démarrer des threads ne fournissent pas de paramètres évidents. si je veux utiliser un thread pour démarrer une méthode avec des paramètres dans une classe ? Ce qui suit est une brève introduction sur la façon d'utiliser le framework riche fourni par .NET pour implémenter cette fonction. Afin de présenter l'ensemble du processus de manière très détaillée, j'ai créé la classe .NET suivante, qui est également le support de la méthode de démarrage du thread. La classe ressemble à ceci :
using System ;
espace de noms WindowsApplication1
{
/// <summary>
/// Description récapitulative de UrlFetcher
/// </summary>
classe publique MyClass{.
// pour la méthode 1
private string _parameter;
public MyClass(string paramètre){
this._parameter = paramètre;
}
public void MyMethod1(){
if(this._parameter!=null){
// faire quelque chose
Console.Write(this._parameter );
}
}
// pour la méthode 2
public MyClass(){}
// cette méthode est privée,Mais elle peut être publique ou autre
privée void MyMethod2(string paramètre){
// faire quelque chose
Console.Write(paramètre }
//
Parce que le délégué WaitCallback's)
;Le type de paramètre est un objet
// Je vais le convertir en chaîne.
public void MyMethod2(objectparameter){
this.MyMethod2((string)parameter)
;
// pour la méthode 3
public string MyMethod3(string paramètre){
return "La valeur du paramètre est :"+paramètre
}
// pour les paramètres mutil transmis
public string MyMutilParameters(string param1,string param2){
return "Le résultat de la connexion du paramètre 1 et du paramètre 2 est : "+param1+param2
}
}
}
Héhé, mon anglais n'est pas bon. Veuillez me pardonner la mauvaise rédaction des commentaires (car ils sont en anglais, j'espère que cela n'affecte pas votre lecture). Je pense qu'il est nécessaire pour moi de parler brièvement du contenu contenu dans le cours ci-dessus. Premièrement, il contient deux constructeurs, un avec des paramètres et un sans (ceci est intentionnellement arrangé). Je pense que vous le devinerez grâce aux noms des autres méthodes de la classe. Je vais présenter 3 méthodes pour passer des paramètres, puis je les présenterai une par une. Voyons d'abord comment démarrer un thread. Tout d'abord, nous pouvons utiliser une fonction pour instancier une instance du délégué ThreadStart, puis utiliser cette instance comme paramètre du nouvel objet thread (Thread), et enfin démarrer le thread que vous souhaitez. en savoir plus Veuillez vous référer à la section Discussion de la documentation MSDN pour plus d'informations.
Afin de tester nos résultats, j'ai créé un projet WinForm, qui comporte un formulaire et 4 boutons. Si vous avez besoin de tout le code source, veuillez envoyer un e-mail à [email protected] . . Ce qui suit est une description détaillée de chaque méthode.
1. Utiliser un constructeur pour passer les paramètres
.Comme nous le savons tous, nous pouvons utiliser un constructeur avec des paramètres pour construire un objet. Dans ce cas, nous pouvons utiliser le constructeur pour transmettre d'abord les valeurs des paramètres à utiliser. variables internes dans l'objet, puis utilisez une méthode Parameter de constructeur sans paramètre pour utiliser ce paramètre (faire semblant d'être un paramètre). Pour faire simple, déclarez une variable dans la classe spécifiquement pour enregistrer les paramètres requis par la fonction, et la fonction devient une forme sans paramètre. Le plus gros problème de cette méthode est qu'elle détruit l'encapsulation. Même si nous ne pouvons pas accéder directement à ces variables, des dangers cachés existent toujours (ou peu importe si cela semble désagréable). L'extrait de code suivant donne les détails sur la façon d'utiliser cette méthode pour transmettre des paramètres. Il s'agit également du code Click pour l'un des quatre boutons mentionnés ci-dessus (Button1). Afin d'avoir des paramètres à transmettre, j'ai défini globalement une variable comme suit dans WinForm :
// Ceci est la valeur du paramètre
private string myParameter = "ParameterValuen" ;
L'événement du bouton est le suivant :
// passé les paramètres au thread par construction
private void button1_Click( object sender, System.EventArgs e) {
MyClass instance = new MyClass(myParameter);
new Thread (new ThreadStart(instance.MyMethod1)).Start(
}
Comme mentionné ci-dessus, nous utilisons le constructeur pour transmettre des paramètres dans la classe Go, puis démarrez un thread en utilisant la méthode mentionnée ci-dessus, nous pouvons voir le résultat de l'exécution de MyMethod1 dans la fenêtre de sortie après avoir exécuté le programme (vous pouvez également utiliser un TextBox ou autre chose pour l'afficher directement sur le WinForm) : Valeur du paramètre. Regardez simplement le corps de la fonction et vous verrez que le résultat est correct. N'est-ce pas très simple.
2. Utilisez ThreadPool pour réaliser le transfert de paramètres.Nous
pouvons d'abord regarder comment MSDN décrit ThreadPool Fournit un pool de threads qui peut être utilisé pour publier des éléments de travail, traiter des E/S asynchrones, attendre pour le compte d'autres threads et traiter des minuteries. Affichez sa collection de méthodes, dont l'une est appelée : QueueUserWorkItem. Pour des informations détaillées sur cette classe et cette méthode, veuillez vous référer à l'aide associée à MSDN. Ce qu'il faut noter ici, ce sont les paramètres de la méthode QueueUserWorkItem. Le paramètre WaitCallback est un type délégué. Le deuxième paramètre est le paramètre requis par l'instance du délégué (après l'avoir instanciée avec une fonction, c'est-à-dire une fonction). de type d'objet. Veuillez consulter le code ci-dessous pour plus de détails.
// passé le paramètre au thread par ThreadPool
private void button2_Click (object sender, System.EventArgs e) {
MyClass instance = new MyClass();
ThreadPool.QueueUserWorkItem (new WaitCallback (instance.MyMethod2),myParameter
}
En raison des deux propriétés
);de QueueUserWorkItem Les paramètres sont de type objet, nous devons donc définir deux versions redimensionnées de MyMethod2 dans MyClass afin de satisfaire les paramètres de la méthode. De même, nous avons transmis le paramètre myParameter et exécuté le programme. Lorsque nous cliquons sur Button2, le résultat de MyMethod2 exécutant myParameter en tant que paramètre apparaîtra dans la fenêtre de sortie.
3. Vient ensuite la dernière méthode pour utiliser la délégation asynchrone pour réaliser le transfert de paramètres
.De même, pour des informations détaillées sur la délégation, veuillez vous référer à MSDN, qui est très détaillé ci-dessus. Nous allons utiliser ici les méthodes BeginInvoke et EndInvoke. Tout d'abord, nous donnons la méthode de transmission d'un paramètre comme suit :
// paramètre passé par un délégué asynchrone
délégué string MyMethod3Delegate (paramètre de chaîne);
private
void button3_Click (expéditeur d'objet, System.EventArgs e) {
MyClass instance = new MyClass ();
myMethod3 = new MyMethod3Delegate(instance.MyMethod3);
myMethod3.BeginInvoke("parameterValue",new AsyncCallback(AfterMyMothod3),null);
}
public void AfterMyMothod3(résultat IAsyncResult){
AsyncResult async =(
AsyncResult) résultat ;
async.AsyncDelegate;
Console.WriteLine ("Valeur de retour de l'appel de fonction : {0}n", DelegateInstance.EndInvoke(result)
}
Tout d'abord, pour utiliser le délégué, nous déclarons un délégué de MyMethod3Delegate, qui spécifie un paramètre. et valeur de retour Les fonctions qui sont des chaînes sont éligibles, nous définissons donc une méthode MyMethod3 dans MyClass. La structure de cette fonction est conforme au délégué ci-dessus, nous pouvons donc utiliser cette méthode pour instancier un délégué lorsque l'on clique sur Button3, puis nous appelons cette méthode de manière asynchrone. Afin d'obtenir le résultat de retour, nous avons écrit la méthode AfterMyMothod3 pour afficher le. résultats de l'exécution de la fonction. Exécutez le programme et cliquez sur Button3 pour voir que les résultats affichés dans Output sont les résultats de l'exécution de MyMethod3 avec des paramètres. Enfin, je donne une méthode sur la façon de passer plusieurs paramètres. Mon exemple est de passer 2 paramètres. Le code est le suivant :
// paramètres mutil transmis
à la chaîne de délégué MyMutilParamsDelegate (paramètre de chaîne 1, paramètre de chaîne 2);
private void button4_Click (expéditeur d'objet, System.EventArgs e) {
instance MyClass = newMyMutilParamsDelegate mutilParams = new MyMutilParamsDelegate (
);
instance.MyMutilParameters );
mutilParams.BeginInvoke("param1","params2",new AsyncCallback(AfterMutilParams),null
}
public void AfterMutilParams(IAsyncResult result){
AsyncResult async = (AsyncResult) result;
MyMutilParamsDelegate DelegateInstance = (MyMutilParamsDelegate) async.AsyncDelegate;
Console.WriteLine ("L'appel de fonction multi-paramètres renvoie le résultat : {0}n", DelegateInstance.EndInvoke( result ));
}
En raison de contraintes d'espace, le code ne sera pas expliqué en détail. Veuillez me corriger s'il y a des inexactitudes. Merci d'avoir lu ! Coordonnées : [email protected] ID du forum CSDN : cuike519
Documents de référence :