Com a versão 2.0 do .NET Framework, novos métodos foram criados para o gerencimento do pool de conexões para Databases, que até então, não tínhamos acesso. De toda a forma, a pooling ainda é gerido pelo .NET, mas temos agora métodos para poder limpar este pool de conexões.

Esta funcionalidade está disponível para os Providers SqlClient e OracleClient, em dois métodos estáticos:

               * ClearPool(Connection) – Limpa o pool e fecha as conexões ativas para uma conexão específica.
                              [ SqlClient ] [ OracleClient ]

               * ClearAllPools – Limpa o pool e fecha todas as conexões ativas.
                              [ SqlClient ] [ OracleClient ]

Bem, a batalha para implementar o NHibernate continua. Precisei há pouco persistir o estado dos meus objetos nas 21 tabelas da DB (SQL Server 2000). Utilizando o NHibernate, o que tive a fazer foi somente criar os arquivos de mappings (a parte mais chata, mas nada muito complicado) e também definir o arquivo de configuração do NHibernate mapeando os arquivos de resources (conforme figura abaixo), quais optei por faze-los em “Embedded Resources”.

Feito isso, é agora somente chamar o método Save(…) e passar o objeto à persistir e tudo magicamente aparece nas devidas tabelas da DB sem escrever uma query SQL, definir parametros, definir e gerir conexões, etc.

Se não estiver a utilizar “Embedded Resources” pode ao invés de fazer o mapping para o Resource, faz-se o mapping diretamente para o arquivo XML.

Bem, aos poucos vou colocando por aqui as novidades sobre este O/RM.

Uma forma rápida de ler arquivos textos sem utilizar as classes contidas no Namespace System.IO e manipular linha a linha do conteúdo do arquivo texto, é utilizando Odbc, que através do mesmo vocè informa na ConnectionString o path do arquivo texto. Na Query faz o SELECT apontando a cláusula FROM para a tua fonte, que no caso é o nome do arquivo.

Definido esses passos, agora pode tratar normalmente como se estivesse utilizando uma Base de Dados Relacional. Exemplo para popular os dados de um DataGrid com os dados vindos do arquivo texto que contém os seguintes dados:

[ Conteúdo do Arquivo.txt ]

Categoria, Codigo
ASP.NET, 1
VB.NET, 2
C#, 3

[ Código ]

Imports System.Data.Odbc
Dim cnn As New OdbcConnection(“Driver={Microsoft Text Driver (*.txt; *.csv)};DBQ=C:”)
Dim cmd As New OdbcCommand(“SELECT * FROM Arquivo.txt”, cnn)
Dim dr As OdbcDataReader
Try
    cnn.Open()
    dr = cmd.ExecuteReader(CommandBehavior.CloseConnection)
    With Me.DataGrid1
        .DataSource = dr
        .DataBind()
    End With
Catch ex As Exception
    Response.Write(“Ocorreu um erro.”)
Finally
    If Not (dr Is Nothing) Then dr.Close()
End Try

Reparem que a primeira linha do conteúdo do “Arquio.txt” torna-se o nome das colunas dos “registros”, qual neste caso, rotula os Headers das colunas do DataGrid. Vale chamar a atenção que o delimitador é a vírgula (“,”).

Ontem recebi um email de um amigo que me pedia se existia alguma forma de pegar o conteúdo de um DataReader e colocar em um DataSet.

Nunca tinha feito isso, e tinha certeza que é possível. Fiquei com tanta curiosidade que decidi colocar a “mão na massa” e tentar fazer essa funcionalidade.

Inicialmente sei que era possível percorrer os registros retornados. A única dúvida que estava um pouco preocupado, foi em como resgatar as colunas (tanto seus valores, quantos seus nomes). Pois bem, fui o Help e procurei pelos membros do DataReader e encontrei a propriedade FieldCount, qual retorna o número de colunas da linha em questão. Com isso, “matei” um problema, mas ainda faltava saber como resgatar o nome da coluna. Da mesma forma, fui ao Help e encontrei o método GetName, que dado um índice, ele retorna o nome desta coluna.

Depois disso, ficou simples, basta apenas percorrer os registros (linhas) do DataReader, e a cada linha, percorrer as colunas da mesma. O código abaixo, ilustra o processo:

        Dim conn As New SqlConnection(“ConnectionString”)
        Dim cmd As New SqlCommand(“SELECT * FROM Categories”, conn)
        Dim dr As SqlDataReader

        Dim i As Integer = 0
        Dim dRow As DataRow
        Dim num2 As Integer
        Dim ds As DataSet = New DataSet

        Try
            conn.Open()
            dr = cmd.ExecuteReader(CommandBehavior.CloseConnection)
            If dr.HasRows() Then
                ds.Tables.Add(“NomeTabela”)
                While dr.Read
                    dRow = ds.Tables(0).NewRow
                    num2 = 0
                    Do While (num2 < dr.FieldCount)
                        If (i = 0) Then
                            ds.Tables(0).Columns.Add(dr.GetName(num2))
                        End If
                        dRow(num2) = dr.GetValue(num2)
                        num2 = (num2 + 1)
                    Loop
                    i = (i + 1)
                    ds.Tables(0).Rows.Add(dRow)
                End While
                dr.Close()
            End If
        Catch ex As Exception
            MessageBox.Show(ex.ToString)
        Finally
            If Not (dr Is Nothing) Then
                dr.Close()
            End If
        End Try

Mas uma coisa que fique bem claro: isso não quer dizer que gosto de DataSets 😉

Existe um Evento da SqlConnection que retorna todas as mensagens geradas pelo SQL Server que não são interpretadas como Exception. É possível recuperar tais mensagens através da SqlConnection. Para isso podemos utilizar o Evento InfoMessage que retorna isso. Abaixo um exemplo de como utilizá-lo:

Criando a StoredProcedure:

CREATE PROCEDURE InfoMessage AS
Print ‘Disparado pelo InfoMessage’
GO

No Evento Load do Formulário:

Private WithEvents conn As SqlClient.SqlConnection
Private Sub Form1_Load(…) Handles MyBase.Load
    conn = New SqlConnection(“…”)
    Dim cmd As SqlCommand = New SqlCommand(“InfoMessage”, conn)
    cmd.CommandType = CommandType.StoredProcedure
    Try
        conn.Open()
        cmd.ExecuteScalar()
        conn.Close()
    Catch ex As Exception
        MessageBox.Show(ex.ToString)
    End Try
End Sub

E no Evento InfoMessage da SqlConnection, capturamos a mensagem da StoredProcedure:

Private Sub conn_InfoMessage(ByVal sender As Object, ByVal e _
    As System.Data.SqlClient.SqlInfoMessageEventArgs) Handles conn.InfoMessage

    MessageBox.Show(e.Message)
End Sub

Com isso, a mensagem que é escrita através do Print do SQL Server, será capturado pelo Evento, e poderá fazer tratamentos no Sistema.

Para os desenvolvedores que utilizam DataSets e DataAdapter, aqui vai uma dica:

Quando utilizamos o DataAdapter, não há a necessidade de abrirmos a conexão com a Base de Dados manualmente, pois ele se encarrega de fazer isso implicitamente. Basta informar a ConnectionString:

Imports System.Data.SqlClient

Dim ds As New DataSet()
Dim da As New SqlDataAdapter(“SELECT * FROM authors”, “ConnectionString”)
da.Fill(ds)
Me.DataGrid1.DataSource = ds