Cuando escribimos programas de comunicación remota u otras aplicaciones, inevitablemente tenemos que lidiar con subprocesos. .Net nos permite crear subprocesos fácilmente, pero los métodos que proporciona para crear subprocesos e iniciar subprocesos no proporcionan parámetros obvios. ¿Si quiero usar un hilo para iniciar un método con parámetros en una clase? La siguiente es una breve introducción sobre cómo utilizar el marco enriquecido proporcionado por .NET para implementar esta función. Para presentar todo el proceso con gran detalle, creé la siguiente clase .NET, que también es portadora del método de inicio del subproceso. La clase se ve así:
usando System;
espacio de nombres WindowsApplication1
{
/// <summary>
/// Descripción resumida de UrlFetcher
/// </summary>
public class MyClass{.
// para el método 1
cadena privada _parameter;
public MyClass(string parámetro){
this._parameter = parámetro;
}
public void MyMethod1(){
if(this._parameter!=null){
// hacer algo
Console.Write(this._parameter )
;
// para el método 2
public MyClass(){}
// este método es privado, pero puede ser público u otro
privado void MyMethod2(string parameter){
// hacer algo
Console.Write(parameter }
//
Porque delegado WaitCallback's; El tipo de parámetro es objeto
// lo convertiré en cadena.
public void MyMethod2(object parameter){
this.MyMethod2((string)parameter
}
// para el método 3
public string MyMethod3(parámetro de cadena){
return "El valor del parámetro es:"+parámetro
}
// para parámetros múltiples pasados
public string MyMutilParameters(string param1,string param2){
return "El resultado de la conexión del parámetro 1 y el parámetro 2 es: "+param1+param2
;
}
}
Jeje, mi inglés no es bueno. Por favor, perdónenme por la mala redacción de los comentarios (porque están en inglés, espero que no afecte su lectura). Creo que es necesario que hable brevemente sobre el contenido de la clase anterior. Primero, contiene dos constructores, uno con parámetros y otro sin (esto está organizado intencionalmente). Creo que lo adivinarás a través de los nombres de otros métodos en la clase. Introduciré 3 métodos para pasar parámetros y luego los presentaré uno por uno. Primero, veamos cómo iniciar un hilo. Primero, podemos usar una función para crear una instancia del delegado ThreadStart, y luego usar esta instancia como parámetro del nuevo objeto de hilo (Thread) y, finalmente, iniciar el hilo. saber más Consulte la sección Hilo de la documentación de MSDN para obtener más información.
Para probar nuestros resultados, creé un proyecto WinForm, que tiene un formulario y 4 botones. Si necesita todo el código fuente, envíe un correo electrónico a [email protected] . Se lo enviaré si tengo tiempo. . Lo que sigue es una descripción detallada de cada método.
1. Use un constructor para pasar parámetros
. Como todos sabemos, podemos usar un constructor con parámetros para construir un objeto. En este caso, podemos usar el constructor para pasar primero los valores de los parámetros que se usarán. variables internas en el objeto y luego use un método de parámetro sin parámetros para usar este parámetro (pretenda ser un parámetro). En pocas palabras, declare una variable en la clase específicamente para guardar los parámetros requeridos por la función, y la función se convierte en una forma sin parámetros. El mayor problema con este método es que destruye la encapsulación. Aunque no podemos acceder directamente a estas variables, siempre existen peligros ocultos (o no importa si parece desagradable). El siguiente fragmento de código brinda detalles sobre cómo usar este método para pasar parámetros. Este es también el código de clic para uno de los cuatro botones mencionados anteriormente (Botón1). Para tener parámetros para pasar, definí una variable de la siguiente manera globalmente en WinForm:
// Este es el valor del parámetro
cadena privada myParameter = "ParameterValuen"
El evento del botón es el siguiente:
// parámetros pasados al subproceso mediante construcción
privada; void button1_Click( remitente del objeto, System.EventArgs e) {
Instancia MyClass = new MyClass(myParameter);
new Thread (new ThreadStart(instance.MyMethod1)).Start()
}
Como se mencionó anteriormente, usamos el constructor para pasar parámetros; la clase Go, y luego iniciar un hilo usando el método mencionado anteriormente, podemos ver el resultado de la ejecución de MyMethod1 en la ventana de salida después de ejecutar el programa (también puede usar un TextBox u otra cosa para mostrarlo directamente en WinForm): Valor del parámetro. Basta con mirar el cuerpo de la función y verás que el resultado es correcto. ¿No es muy simple?
2. Utilice ThreadPool para realizar la transferencia de parámetros.
Primero podemos ver cómo describe MSDN ThreadPool. Proporciona un grupo de subprocesos que se pueden utilizar para publicar elementos de trabajo, procesar E/S asincrónicas, esperar en nombre de otros subprocesos y procesar temporizadores. Vea su colección de métodos, uno de los cuales se llama: QueueUserWorkItem. Para obtener información detallada sobre esta clase y este método, consulte la ayuda relacionada con MSDN. Lo que hay que tener en cuenta aquí son los parámetros del método QueueUserWorkItem. El parámetro WaitCallback es un tipo de delegado. El segundo parámetro es el parámetro requerido por la instancia delegada (después de crear una instancia con una función, es decir, una función). de tipo de objeto. Consulte el código a continuación para obtener más detalles.
// pasó el parámetro al subproceso mediante ThreadPool
private void button2_Click(object sender, System.EventArgs e) {
MyClass instancia = new MyClass();
ThreadPool.QueueUserWorkItem (new WaitCallback (instance.MyMethod2),myParameter
}
Debido a las dos propiedades
);de QueueUserWorkItem Los parámetros son de tipo objeto, por lo que necesitamos definir dos versiones redimensionadas de MyMethod2 en MyClass para satisfacer los parámetros del método. De manera similar, pasamos el parámetro myParameter y ejecutamos el programa. Cuando hacemos clic en Button2, el resultado de MyMethod2 ejecutando myParameter como parámetro aparecerá en la ventana de salida.
3. El siguiente es el último método para utilizar la delegación asincrónica para realizar la transferencia de parámetros
. De manera similar, para obtener información detallada sobre la delegación, consulte MSDN, que se detalla anteriormente. Aquí utilizaremos los métodos BeginInvoke y EndInvoke. Primero, damos el método para pasar un parámetro de la siguiente manera:
// parámetro pasado por delegado asincrónico
cadena de delegado MyMethod3Delegate(parámetro de cadena);
private void button3_Click(remitente del objeto, System.EventArgs e) {
instancia deMyClass
= new MyClass();
myMethod3 = new MyMethod3Delegate(instance.MyMethod3);
myMethod3.BeginInvoke("parameterValue",new AsyncCallback(AfterMyMothod3),null);
}
public void AfterMyMothod3(resultado de IAsyncResult){
AsyncResult async = (AsyncResult)
resultado;
async.AsyncDelegate;
Console.WriteLine ("Valor de retorno de llamada de función: {0}n", DelegateInstance.EndInvoke(result)
}
Primero, para usar el delegado, declaramos un delegado de MyMethod3Delegate, que especifica un parámetro. y valor de retorno Las funciones que son cadenas son elegibles, por lo que definimos un método MyMethod3 en MyClass. La estructura de esta función se ajusta al delegado anterior, por lo que podemos usar este método para crear una instancia de un delegado cuando se hace clic en Button3, y luego llamamos a este método de forma asincrónica. Para obtener el resultado devuelto, escribimos el método AfterMyMothod3 para mostrar el. resultados de la ejecución de la función. Ejecute el programa y haga clic en Botón3 para ver que los resultados generados en Salida son los resultados de la ejecución de MyMethod3 con parámetros. Finalmente, doy un método sobre cómo pasar múltiples parámetros. Mi ejemplo es pasar 2 parámetros. El código es el siguiente:
// parámetros múltiples pasados
cadena delegada MyMutilParamsDelegate(parámetro de cadena1, parámetro de cadena2);
botón vacío privado4_Click(remitente de objeto, System.EventArgs e) {
instancia de MyClass = new
MyMutilParamsDelegate mutilParams = new MyMutilParamsDelegate( instancia.MyMutilParameters);
mutilParams.BeginInvoke("param1","params2",new AsyncCallback(AfterMutilParams),null)
;
public void AfterMutilParams(resultado de IAsyncResult){
AsyncResult async = (AsyncResult) resultado;
MyMutilParamsDelegate DelegateInstance = (MyMutilParamsDelegate) async.AsyncDelegate
Console.WriteLine ("La llamada a función multiparámetro devuelve el resultado: {0}n", DelegateInstance.EndInvoke( resultado ));
}
Debido a limitaciones de espacio, el código no se explicará en detalle. Corríjame si hay alguna inexactitud. ¡Gracias por leer! Información de contacto: [email protected] ID del foro CSDN: cuike519
Documentos de referencia: