Há algum tempo, escrevi um post que mostra formas de programar threads em C# e VB.NET. Na ocasião, mostrei uma forma de passar parâmetros para uma thread. O intuito deste post é mostrar uma outra forma existente para este mesmo objetivo.

Primeiro, criamos uma classe que conterá propriedades que representarão os parâmetros que devem ser passados para a Thread.

// C#
public class DadosLog
{
    public Exception Exception { get; set; }
    public string StrNomeProjeto { get; set; }
    public string StrNomeClasse { get; set; }
    public string StrNomeMetodo { get; set; }
}
' VB.NET
Public Class DadosLog
    Public Property Exception() As Exception
        Get
            Return _Exception
        End Get
        Set(ByVal value As Exception)
            _Exception = value
        End Set
    End Property
    Private _Exception As Exception
    Public Property StrNomeProjeto() As String
        Get
            Return _StrNomeProjeto
        End Get
        Set(ByVal value As String)
            _StrNomeProjeto = value
        End Set
    End Property
    Private _StrNomeProjeto As String
    Public Property StrNomeClasse() As String
        Get
            Return _StrNomeClasse
        End Get
        Set(ByVal value As String)
            _StrNomeClasse = value
        End Set
    End Property
    Private _StrNomeClasse As String
    Public Property StrNomeMetodo() As String
        Get
            Return _StrNomeMetodo
        End Get
        Set(ByVal value As String)
            _StrNomeMetodo = value
        End Set
    End Property
    Private _StrNomeMetodo As String
End Class

Em seguida, o método que executará o processo em segundo plano deve ter como parâmetro de entrada um object.

// C#
public void ExecutarLogErro(object _dadosLog)
{
    DadosLog dadosLog = (_dadosLog as DadosLog);

    // Gravar Log no Repositório ou no Log de Eventos do Windows
}
' VB.NET
Public Sub ExecutarLogErro(ByVal _dadosLog As Object)
    Dim dadosLog As DadosLog = TryCast(_dadosLog, DadosLog)

    ' Gravar Log no Repositório ou no Log de Eventos do Windows
End Sub

Para concluir, passamos a instância da classe DadosLog no método Start() no momento da chamada à thread.

// C#
public void LogarErro(Exception exception,
    string strNomeProjeto,
    string strNomeClasse,
    string strNomeMetodo)
{
    DadosLog dadosLog = new DadosLog()
    {
        Exception = exception,
        StrNomeClasse = strNomeClasse,
        StrNomeMetodo = strNomeMetodo,
        StrNomeProjeto = strNomeProjeto
    };

    GerenciaLogErro gle = new GerenciaLogErro();
    Thread t = new Thread(gle.ExecutarLogErro);
    t.IsBackground = true;
    t.Start(dadosLog);
}
' VB.NET
Public Sub LogarErro(ByVal exception As Exception, _
                     ByVal strNomeProjeto As String, _
                     ByVal strNomeClasse As String, _
                     ByVal strNomeMetodo As String)
    Dim dadosLog As New DadosLog() With { _
     .Exception = exception, _
     .StrNomeClasse = strNomeClasse, _
     .StrNomeMetodo = strNomeMetodo, _
     .StrNomeProjeto = strNomeProjeto _
    }

    Dim gle As New GerenciaLogErro()
    Dim t As New Thread(AddressOf gle.ExecutarLogErro)
    t.IsBackground = True
    t.Start(dadosLog)
End Sub

Essa é apenas mais uma maneira de passar informações para a Thread. Existem outras e mais para frente tentarei demonstrar aqui.

OBS: Este código fonte pode ser baixado aqui.

Obrigado.

Anúncios