Quando escrevemos programas remotos ou outros aplicativos, inevitavelmente temos que lidar com threads. O Net nos permite criar facilmente um thread, mas os métodos que ele fornece para criar e iniciar threads não fornecem parâmetros óbvios. se eu quiser usar um thread para iniciar um método com parâmetros em uma classe? A seguir está uma breve introdução sobre como usar a rica estrutura fornecida pelo .NET para implementar esta função. Para apresentar todo o processo em detalhes, criei a seguinte classe .NET, que também é a portadora do método de inicialização do thread. A classe fica assim:
using System;
namespace WindowsApplication1
{
/// <summary>
/// Descrição resumida para UrlFetcher
/// </summary>
public class MyClass{
// para o método 1
private string _parameter;
public MyClass(string parâmetro){
this._parameter = parâmetro
}
public void MyMethod1(){
if(this._parameter!=null){
// faça algo
Console.Write(this._parameter) );
}
}
// para o método 2
public MyClass(){}
// este método é privado, mas pode ser público ou outro
privado void MyMethod2(string parâmetro){
// faça algo
Console.Write(parameter }
//
Porque delegar WaitCallback's
);parâmetro Tipo é objeto
// vou convertê-lo em string.
public void MyMethod2(object parâmetro){
this.MyMethod2((string)parameter
}
);
// para o método 3
public string MyMethod3(string parâmetro){
return "O valor do parâmetro é:"+parameter
}
;
// para parâmetros múltiplos passados
public string MyMutilParameters(string param1,string param2){
return "O resultado da conexão do parâmetro 1 e do parâmetro 2 é: "+param1+param2
}
;
}
}
Hehe, meu inglês não é bom. Por favor, me perdoe pela má redação dos comentários (porque estão em inglês). Acho necessário falar brevemente sobre o conteúdo contido na aula acima. Primeiro, ele contém dois construtores, um com parâmetros e outro sem (isso é organizado intencionalmente). Acho que você vai adivinhar pelos nomes de outros métodos da classe. Apresentarei 3 métodos para passar parâmetros e depois os apresentarei um por um. Primeiro, vamos ver como iniciar um thread. Primeiro, podemos usar uma função para instanciar uma instância do delegado ThreadStart e, em seguida, usar essa instância como parâmetro do novo objeto de thread (Thread) e, finalmente, iniciar o thread. saiba mais Consulte a seção Thread da documentação do MSDN para obter mais informações.
Para testar nossos resultados, criei um projeto WinForm, que possui um Formulário e 4 botões. Se precisar de todo o código-fonte, envie um e-mail para [email protected] . . O que se segue é uma descrição detalhada de cada método.
1. Use um construtor para passar parâmetros
. Como todos sabemos, podemos usar um construtor com parâmetros para construir um objeto. Nesse caso, podemos usar o construtor para primeiro passar os valores dos parâmetros a serem usados para o objeto. variáveis internas no objeto e, em seguida, use um método Parameter sem parâmetros para usar esse parâmetro (finja ser um parâmetro). Simplificando, declare uma variável na classe especificamente para salvar os parâmetros exigidos pela função, e a função se tornará uma forma sem parâmetros. O maior problema com este método é que ele destrói o encapsulamento. Embora não possamos acessar diretamente essas variáveis, sempre existem perigos ocultos (ou não importa se parece desagradável). O trecho de código a seguir fornece detalhes de como usar este método para passar parâmetros. Este também é o código Click para um dos quatro botões mencionados acima (Button1). Para ter parâmetros para passar, defini uma variável globalmente no WinForm:
//
Este
é
o valor do parâmetro
private string myParameter = "ParameterValuen";
void button1_Click( object sender, System.EventArgs e) {
MyClass instance = new MyClass(myParameter);
new Thread (new ThreadStart(instance.MyMethod1)).Start()
}
Como mencionado acima, usamos o construtor para passar parâmetros para dentro a classe Go, e então iniciar um thread usando o método mencionado acima, podemos ver o resultado da execução de MyMethod1 na janela de saída após executar o programa (você também pode usar um TextBox ou outra coisa para exibi-lo diretamente no WinForm): ParâmetroValor. Basta olhar para o corpo da função e você verá que o resultado está correto. Não é muito simples.
2. Use ThreadPool para realizar a transferência de parâmetros.
Podemos primeiro ver como o MSDN descreve ThreadPool. Fornece um conjunto de threads que pode ser usado para postar itens de trabalho, processar E/S assíncrona, esperar em nome de outros threads e processar temporizadores. Veja sua coleção de métodos, um dos quais é chamado: QueueUserWorkItem Para obter informações detalhadas sobre esta classe e este método, consulte a ajuda relacionada ao MSDN. O que precisa ser observado aqui são os parâmetros do método QueueUserWorkItem. O parâmetro WaitCallback é um tipo delegado. O segundo parâmetro é o parâmetro exigido pela instância delegada (após instanciá-lo com uma função, ou seja, uma função). do tipo de objeto. Por favor, veja o código abaixo para obter detalhes.
// parâmetro passado para thread por ThreadPool
private void button2_Click(object sender, System.EventArgs e) {
MyClass
instance = new MyClass(
)
;
de QueueUserWorkItem Os parâmetros são do tipo objeto, portanto precisamos definir duas versões redimensionadas de MyMethod2 em MyClass para satisfazer os parâmetros do método. Da mesma forma, passamos o parâmetro myParameter e executamos o programa. Quando clicamos em Button2, o resultado de MyMethod2 executando myParameter como parâmetro aparecerá na janela de saída.
3. O próximo é o último método para usar a delegação assíncrona para realizar a transferência de parâmetros
. Da mesma forma, para obter informações detalhadas sobre a delegação, consulte o MSDN, que é muito detalhado acima. Usaremos os métodos BeginInvoke e EndInvoke aqui. Primeiro, fornecemos o método de passagem de um parâmetro da seguinte forma:
// parâmetro passado por delegado assíncrono
delegado string MyMethod3Delegate(string parâmetro);
private void button3_Click(object sender, System.EventArgs e) {
MyClass instance = new MyMethod3Delegate()
; myMethod3 = new MyMethod3Delegate(instance.MyMethod3);
myMethod3.BeginInvoke("parameterValue",new AsyncCallback(AfterMyMothod3),null }
public
void AfterMyMothod3(IAsyncResult result){
AsyncResult async =(
AsyncResult) resultado;
async.AsyncDelegate;
Console.WriteLine ("Valor de retorno da chamada de função: {0}n", DelegateInstance.EndInvoke(result)
}
Primeiro, para usar o delegado, declaramos um delegado de MyMethod3Delegate, que especifica um parâmetro e valor de retorno Funções que são strings são elegíveis, portanto, definimos um método MyMethod3 em MyClass. A estrutura desta função está em conformidade com o delegado acima, portanto, podemos usar este método para instanciar um delegado quando Button3 é clicado e, em seguida, chamamos esse método de forma assíncrona. Para obter o resultado de retorno, escrevemos o método AfterMyMothod3 para exibir o. resultados de execução de função. Execute o programa e clique em Button3 para ver se os resultados gerados em Output são os resultados da execução de MyMethod3 com parâmetros. Finalmente, dou um método sobre como passar vários parâmetros. Meu exemplo é passar 2 parâmetros. O código é o seguinte:
// parâmetros múltiplos passados
delegado string MyMutilParamsDelegate(string parâmetro1,string parâmetro2);
private void button4_Click(object sender, System.EventArgs e) {
MyClass instance = new MyMutilParamsDelegate
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
("Chamada de função multiparâmetro retorna resultado: {0}n", DelegateInstance.EndInvoke( result ));
}
Devido a restrições de espaço, o código não será explicado em detalhes. Por favor, corrija-me se houver alguma imprecisão. Obrigado por ler! Informações de contato: [email protected] ID do fórum CSDN: cuike519
Documentos de referência: