Pagina 1 di 3 1 2 3 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 24
  1. #1
    Utente di HTML.it L'avatar di Legnetto
    Registrato dal
    May 2002
    Messaggi
    1,419

    Accesso ai dati personalizzato

    Prima di tutto, mi scuso per il titolo del topic ma, non sono riuscito ad estrapolare in modo sintetico il "succo" della discussione che sto aprendo.
    La mia esigenza sarebbe quella di accedere a dati(presi da db) che normalmente utilizzano come motore di database sqlserver però, lo stesso programma deve funzionare anche con oracle.
    Adesso questa applicazione che avevo fatto anni fa, utilizza come provider oledb per poter funzionare correttamente con entrambi i db, devo modificarla per altri motivi e volevo anche crearmi una classe di oggetti personalizzati che mi ritornasse dei mio_datareader, mio_dataset ecc.
    Nulla di difficile per quanto riguarda la creazione dei vari dataset, datatable perchè non sono personalizzati per la connessione, il problema sorge per il datareader che in concomitanza di una connessione sql diventa un sqldatareader negli altri casi un oledbdatareader.
    Io voglio sovrascrivere gli oggetti nativi per mantenerne tutte le funzionalità, ad esempio nel codice se voglio interrogare un datareader per vedere se ci sono record, mi interessa avere a disposizione la proprietà hasrows, senza doverla creare exnovo partendo da un controllo object.
    Tutto questo chiaramente per sfruttare le differenze di performance che ci sono sfruttando i provider nativi per sqlclient.
    Volgio fare tutto in una classe esterna perchè per me questa esigenza diventerà lo standard per l'accesso ai dati.

    Grazie a chi avrà qualche suggerimento da darmi
    Legnetto

  2. #2
    Utente di HTML.it L'avatar di albgen
    Registrato dal
    Jun 2005
    Messaggi
    3,249
    in poche parole devi utilizzare questo pattern
    http://en.wikipedia.org/wiki/Factory_method_pattern
    è la stessa cosa che hanno fatto anche nel framework .net per l'accesso ai dati !
    I got the remedy

  3. #3
    Utente di HTML.it L'avatar di Legnetto
    Registrato dal
    May 2002
    Messaggi
    1,419
    Originariamente inviato da albgen
    in poche parole devi utilizzare questo pattern
    http://en.wikipedia.org/wiki/Factory_method_pattern
    è la stessa cosa che hanno fatto anche nel framework .net per l'accesso ai dati !
    Grazie mille, link interessantissimo.

    Legnetto

  4. #4
    Moderatore di ASP.net L'avatar di djciko
    Registrato dal
    Nov 2002
    Messaggi
    6,887
    Io ho fatto il mio 'sotto-framework' per l'accesso ai dati dividendo il tutto in due NameSpaces:
    SqlTools e OleDbTools. Ognuno contiene le stesse classi che estraggono DataTable, DataSet, DataReader, con il giusto provider. Ho fatto anche dei metodi per automatizzare il passaggio di parametri alle Stored Procedure...

    Comunque c'e' uno strato di software già fatto da Microsoft di cui non ricordo il nome

  5. #5
    Utente di HTML.it L'avatar di Legnetto
    Registrato dal
    May 2002
    Messaggi
    1,419
    Ma nelle tue classi però, non puoi utilizzare come ho descritto sopra ad esempio un reader.
    Magari non ho capito ma tu farai una cosa del tipo:
    dim mioreader as new sqltools.get_reader
    e quello sarà funzionante con sqlclient ma, se lo stesso codice dovesse funzionare con oledb e sqlclient non andrebbe.
    Chiedo il beneficio del dubbio perchè mi sfugge sicuramente qualcosa.
    Se puoi chiarire un po meglio sarebbe interessante.
    Ciao e grazie.
    Legnetto

  6. #6
    Moderatore di ASP.net L'avatar di djciko
    Registrato dal
    Nov 2002
    Messaggi
    6,887
    Ho fatto semplicemente dei metodi che restituiscono un DataReader.
    No, non faccio Dim mioReader as SqlTools etc ma:

    codice:
    Dim Database as new SqlTools
    Database.SQL = Stringasql
    Dim reader as SqlDataReader = Database.EstraiDataReader()
    Se devi fare un solo codice che funzioni per tutti i provider beh la strada 'a monte' è diversa, il provider deve essere una proprietà che imposti, magari passandogli anche la connectionstring giusta...

  7. #7
    Utente di HTML.it L'avatar di Legnetto
    Registrato dal
    May 2002
    Messaggi
    1,419
    Dove ho implemetato quello che volgio fare dappertutto nel codice, utlizzo questo sistema per intercettare quello che c'è nel web.config.
    codice:
    Dim Conn As Object
    Dim provider As String = ConfigurationManager.ConnectionStrings("connectionstring").ProviderName
            If InStr(provider, "SqlClient") > 0 Then
                Conn = New SqlConnection
                sql_conn = True
            Else
                Conn = New OleDbConnection
            End If
    e poi con un if verifico al variabile boolean sql_conn ed istanzio di conseguenza oggetti oledb oppure sqlclient.
    Così facendo l'applicazione funziona sia con oledb che con sqlclient cambiando solo la connectionstring nel web.config.
    Anche se funziona in questo caso va bene perchè ci sono poche accessi al db, in altre pagine complesse sarebbe un incubo.
    Da qui nasce l'esigenza di avere una classe esterna.
    Ciao e grazie
    Legnetto

  8. #8
    Utente di HTML.it L'avatar di pietro09
    Registrato dal
    Jan 2002
    Messaggi
    10,116
    1) Come ti comporti con le stringhe sql che contengono parametri? :master:

    2) come ti comporti con le stringhe sql che contengono nomi di funzione proprietari? (esempio lower di oracle)

    :master:
    Pietro

  9. #9
    Moderatore di ASP.net L'avatar di djciko
    Registrato dal
    Nov 2002
    Messaggi
    6,887
    Originariamente inviato da Legnetto
    Dove ho implemetato quello che volgio fare dappertutto nel codice, utlizzo questo sistema per intercettare quello che c'è nel web.config.
    codice:
    Dim Conn As Object
    Dim provider As String = ConfigurationManager.ConnectionStrings("connectionstring").ProviderName
            If InStr(provider, "SqlClient") > 0 Then
                Conn = New SqlConnection
                sql_conn = True
            Else
                Conn = New OleDbConnection
            End If
    e poi con un if verifico al variabile boolean sql_conn ed istanzio di conseguenza oggetti oledb oppure sqlclient.
    Così facendo l'applicazione funziona sia con oledb che con sqlclient cambiando solo la connectionstring nel web.config.
    Anche se funziona in questo caso va bene perchè ci sono poche accessi al db, in altre pagine complesse sarebbe un incubo.
    Da qui nasce l'esigenza di avere una classe esterna.
    Ciao e grazie
    Legnetto
    Io sono per la separazione, sempre

  10. #10
    Moderatore di ASP.net L'avatar di djciko
    Registrato dal
    Nov 2002
    Messaggi
    6,887
    codice:
    NameSpace Libreria
        Public Class SqlTools
    
            Private _StringaConnessione As String
            Public Property StringaConnessione() As String
                Get
                    Return _StringaConnessione
                End Get
    
                Set(ByVal Value As String)
                    _StringaConnessione = Value
                End Set
            End Property
    
            Private _SQL As String
            Public Property SQL() As String
                Get
                    Return _SQL
                End Get
    
                Set(ByVal Value As String)
                    _SQL = Value
                End Set
            End Property
    
            ' Proprietà Private
            Private internal_SQLCONN As SqlConnection
            Private internal_READER As SqlDataReader
            Private internal_SQLCOMMAND As SqlCommand
            Private internal_SQLADAPTER As SqlDataAdapter
            Private internal_DATASET As DataSet
    
            Public Sub New()
                ' Settaggio StringaConn
                Me.StringaConnessione = ConfigurationManager.AppSettings("nomeapplicazione")
            End Sub
    
            Private Sub Connetti()
                Try
                    internal_SQLCONN = New SqlConnection(StringaConnessione)
                    internal_SQLCONN.Open()
                Catch ex As SqlException
                    internal_SQLCONN.Close()
                    Me._SQL = ""
                    Me._StringaConnessione = ""
                    Throw ex
                End Try
            End Sub
    
            Public Function EstraiDataSet(ByVal strNomeDataTable As String) As DataSet
                Connetti()
                internal_DATASET = New DataSet
                internal_SQLADAPTER = New SqlDataAdapter(Me._SQL, internal_SQLCONN)
                Try
                    internal_SQLADAPTER.Fill(internal_DATASET, strNomeDataTable)
                    Return internal_DATASET
                Catch ex As SqlException
                    Throw ex
                    Return Nothing
                Finally
                    internal_SQLCONN.Close()
                End Try
            End Function
    
            Public Function EstraiDataTable(ByVal strNomeDataTable As String) As DataTable
                Connetti()
                internal_DATASET = New DataSet
                internal_SQLADAPTER = New SqlDataAdapter(Me._SQL, internal_SQLCONN)
                Try
                    internal_SQLADAPTER.Fill(internal_DATASET, strNomeDataTable)
                    Return internal_DATASET.Tables(0)
                Catch ex As SqlException
                    Throw ex
                    Return Nothing
                Finally
                    internal_SQLCONN.Close()
                End Try
            End Function
    
            Public Shared Function EstraiDataTable_AutoSelect(ByVal strNomeTabella As String) As DataTable
                Dim db As New LIBRERIA.Database.SqlTools
                db.Connetti()
                db.internal_DATASET = New DataSet
                db.internal_SQLADAPTER = New SqlDataAdapter("SELECT * FROM " & strNomeTabella, db.internal_SQLCONN)
                Try
                    db.internal_SQLADAPTER.Fill(db.internal_DATASET, strNomeTabella)
                    Return db.internal_DATASET.Tables(0)
                Catch ex As SqlException
                    Throw ex
                    Return Nothing
                Finally
                    db.internal_SQLCONN.Close()
                End Try
            End Function
    
            ' Restituisce un SqlDataReader
            Public Function EstraiDataReader() As SqlDataReader
                Connetti()
                internal_SQLCOMMAND = New SqlCommand(Me._SQL, internal_SQLCONN)
                Try
                    internal_READER = internal_SQLCOMMAND.ExecuteReader()
                    Return internal_READER
                Catch ex As SqlException
                    Throw ex
                    internal_SQLCONN.Close()
                    Return Nothing
                Finally
                    internal_SQLCOMMAND.Dispose()
                End Try
            End Function
    
            ' INSERT, UPDATE, DELETE
            Public Function ModificaDatabase() As Boolean
                Connetti()
                internal_SQLCOMMAND = New SqlCommand(Me._SQL, internal_SQLCONN)
                Try
                    Dim affected As Integer
                    ' Execute non query è per comandi non-select
                    affected = internal_SQLCOMMAND.ExecuteNonQuery()
                    If affected > 0 Then
                        Return True
                    End If
                Catch ex As SqlException
                    Throw ex
                    Return False
                Finally
                    internal_SQLCONN.Close()
                    internal_SQLCOMMAND.Dispose()
                End Try
            End Function
    
            ' Restituisce un DataTable che contiene lo schema della tabella
            Public Function Schema() As DataTable
                Connetti()
                internal_SQLCOMMAND = New SqlCommand(Me._SQL, internal_SQLCONN)
                Dim internal_DataTable As DataTable
                Try
                    internal_READER = internal_SQLCOMMAND.ExecuteReader(CommandBehavior.KeyInfo Or CommandBehavior.SchemaOnly)
                    internal_DataTable = internal_READER.GetSchemaTable()
                    Return internal_DataTable
                Catch ex As SqlException
                    Return Nothing
                Finally
                    internal_READER.Close()
                    internal_SQLCONN.Close()
                    internal_SQLCOMMAND.Dispose()
                End Try
            End Function
    
            ' ---------------------------------------------
            ' Esegue una Stored Procedure SENZA PARAMETRI
            ' ---------------------------------------------
            Public Sub EseguiStored(ByVal nomeSP As String)
                Dim ds As New DataSet
                Dim dt As New DataTable
                Dim cn As SqlConnection = New SqlConnection(Me._StringaConnessione)
                Dim cmd As SqlCommand = New SqlCommand(nomeSP, cn)
                cmd.CommandType = CommandType.StoredProcedure
                cmd.CommandText = nomeSP
                Try
                    cn.Open()
                    cmd.ExecuteNonQuery()
                Catch dataex As SqlException
                    Throw dataex
                Catch ex As Exception
                    Throw ex
                Finally
                    cn.Close()
                    cmd.Dispose()
                End Try
            End Sub
    
    
            ' ------------------------------------------------------------------------
            ' Esegue una Stored Procedure SENZA PARAMETRI e restituisce un Datatable
            ' ------------------------------------------------------------------------
            Public Function EseguiStored_Datatable(ByVal nomeSP As String) As DataTable
                Dim ds As New DataSet
                Dim dt As New DataTable
                Dim cn As SqlConnection = New SqlConnection(Me._StringaConnessione)
                Dim cmd As SqlCommand = New SqlCommand(nomeSP, cn)
                cmd.CommandType = CommandType.StoredProcedure
                cmd.CommandText = nomeSP
                Dim adapter As New SqlDataAdapter(cmd)
                Try
                    cn.Open()
                    adapter.Fill(ds)
                    dt = ds.Tables(0)
                    Return dt
                Catch dataex As DataException
                    Throw dataex
                Catch ex As Exception
                    Throw ex
                Finally
                    cn.Close()
                    cmd.Dispose()
                End Try
            End Function
    
            ' ---------------------------------------------
            ' Esegue una Stored Procedure CON PARAMETRI
            ' ---------------------------------------------
            Public Sub EseguiStoredConParametri(ByVal nomeSP As String, ByVal pars As SqlParameter())
                Dim cn As SqlConnection = New SqlConnection(Me._StringaConnessione)
    
                Dim cmd As SqlCommand = New SqlCommand
                cmd.CommandText = nomeSP ' Il commandtext è la SP ricevuta
                cmd.Connection = cn ' Assegna la connessione
    
                cmd.CommandType = CommandType.StoredProcedure
                Dim ad As SqlDataAdapter
                For Each p As SqlParameter In pars
                    cmd.Parameters.Add(p)
                Next
                Try
                    cn.Open()
                    cmd.ExecuteNonQuery()
                Catch dataex As DataException
                    Throw dataex
                Catch ex As Exception
                    Throw ex
                Finally
                    cn.Close()
                    cmd.Dispose()
                End Try
            End Sub
    
            ' ------------------------------------------------------------------------
            ' Esegue una Stored Procedure CON PARAMETRI e restituisce un DTable
            ' ------------------------------------------------------------------------
            Public Function EseguiStoredConParametri_Datatable(ByVal nomeSP As String, ByVal pars As SqlParameter()) As DataTable
                Dim ds As New DataSet
                Dim dt As New DataTable
                Dim cn As SqlConnection = New SqlConnection(Me._StringaConnessione)
                Dim cmd As SqlCommand = New SqlCommand(nomeSP, cn)
    
                cmd.CommandType = CommandType.StoredProcedure
    
                For Each p As SqlParameter In pars
                    cmd.Parameters.Add(p)
                Next
    
                Dim adapter As New SqlDataAdapter(cmd)
                Try
                    cn.Open()
                    adapter.Fill(ds)
                    dt = ds.Tables(0)
                    Return dt
                Catch dataex As DataException
                    Throw dataex
                Catch ex As Exception
                    Throw ex
                Finally
                    cn.Close()
                    cmd.Dispose()
                End Try
            End Function
    End Class
    End NameSpace
    e' un vecchio codice che avrà anche delle imperfezioni, ma tutto sommato funziona e fa il suo sporco lavoro

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.