Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

Ho questo metodo " public List<dmMsg> loadDM_MSG() { try { List<dmMsg> dmMsg = new…

  1. User

    Ho questo metodo " public List loadDM_MSG() { try { List dmMsg = new List();

                StringBuilder sb = new StringBuilder();
    
                /*
                 *select B.AOO,A.* from DM_MSG A
    

    inner join DM_UTENTI B on A.A=B.Email where (A.ID_MITT is null or A.ID_MITT=0) union all select B.AOO,A.* from DM_MSG A inner join DM_UTENTI B on A.ID_MITT=B.UTENTE where (A.ID_MITT is not null and A.ID_MITT<>0)

                             sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, DM_UTENTI.AOO AS AOO ");
                sb.Append("FROM DM_MSG INNER JOIN DM_UTENTI ON DM_MSG.ID_MITT = DM_UTENTI.Utente ");
                sb.Append("WHERE (DM_MSG.ID_MITT IS NOT NULL AND DM_MSG.ID_MITT <> 0 AND DM_MSG.CSTRING <> '' )");
                sb.Append("UNION ");
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, DM_UTENTI.AOO AS AOO ");
                sb.Append("FROM DM_MSG INNER JOIN DM_UTENTI ON DM_MSG.A = DM_UTENTI.Email WHERE (DM_MSG.ID_MITT IS NULL OR DM_MSG.ID_MITT = 0) AND  DM_MSG.CSTRING <> ''");
    
                 * */
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, DM_UTENTI.AOO AS AOO, DM_MSG.PSWZIP ");
                sb.Append("FROM DM_MSG, DM_UTENTI ");
                sb.Append($"WHERE DM_MSG.ID_MITT = DM_UTENTI.Utente AND DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 ");
                sb.Append("UNION ");
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, '' AS AOO, DM_MSG.PSWZIP ");
                sb.Append($"FROM DM_MSG WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND DM_MSG.ID_MITT IS NULL");
    
                DbCommand command = _dbConnection.CreateCommand();
                command.CommandText = sb.ToString();
                command.CommandType = CommandType.Text;
    
                using (DbDataReader reader = command.ExecuteReader())
                {
                    if (reader.HasRows)
                    {
                        while (reader.Read())
                        {
                            var _dmMsgItem = new dmMsg()
                            {
                                _id = MongoDB.Bson.ObjectId.GenerateNewId(),
                                ID = System.Convert.ToInt32(reader["ID"]),
                                storeDate = System.Convert.ToDateTime(reader["DATA"]),
                                fileName = reader["FILENAME"].ToString(),
                                cstring = reader["CSTRING"].ToString(),
                                compressionMode = System.Convert.ToInt32(reader["COMPRESSIONMODE"]),
                                aoo = reader["AOO"].ToString(),
                                pswzip = reader["PSWZIP"].ToString()
                            };
    
                            dmMsg.Add(_dmMsgItem);
                        }
                    }
                }
    
                return dmMsg;
    
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }"
    

    la query deve funzionare sia per sql sia per oracle

    il valore di _lengthFunction è LENGTH o LEN in base a oracle o sql

  2. Assistant

    Per far funzionare la query sia su Oracle che su SQL Server, la gestione della funzione di lunghezza della stringa (LENGTH in Oracle e LEN in SQL Server) è corretta, e il codice che hai scritto si basa proprio su questa logica tramite la variabile _lengthFunction.

    Qui sotto alcuni suggerimenti per assicurarti che il metodo funzioni correttamente su entrambi i database:


    1. Definire _lengthFunction dinamicamente

    Puoi determinare il valore di _lengthFunction in base al tipo di database che stai usando, ad esempio durante l'inizializzazione della classe o del componente, oppure passarla come parametro.

    string _lengthFunction;
    
    if (_dbConnection.GetType().Name.Contains("Oracle")) {
        _lengthFunction = "LENGTH";
    }
    else if (_dbConnection.GetType().Name.Contains("Sql")) {
        _lengthFunction = "LEN";
    }
    else {
        throw new NotSupportedException("Database non supportato");
    }
    

    2. Query SQL con stile compatibile

    La query che hai scritto è valida a livello sintattico per entrambi i db, se usi la funzione giusta per la lunghezza.

    Un piccolo suggerimento: nelle condizioni sui join e agli alias, assicurati che nella query non ci siano problemi di case sensitive o alias non necessari, ma per le funzioni base come LENGTH o LEN va bene.


    3. Nota sull’uso di UNION

    Tieni conto che in Oracle per fare UNION di query con colonne di tipo testo potrebbe essere importante che le colonne combacino esattamente in tipo e lunghezza (es. VARCHAR2 vs VARCHAR). Ma in gran parte dei casi, se i tipi sono identici nelle tabelle, non è problema.


    4. Comandi parametrizzati

    Nel codice non vedo parametri, quindi va bene così, ma attenzione a concatenazioni se costruisci condizioni più complesse in futuro.


    5. Esempio completo con determina funzione lunghezza

    Esempio semplificato per impostare la variabile e comporre la query:

    string _lengthFunction;
    if (_dbConnection.GetType().Name.ToLower().Contains("oracle"))
    {
        _lengthFunction = "LENGTH";
    }
    else if (_dbConnection.GetType().Name.ToLower().Contains("sql"))
    {
        _lengthFunction = "LEN";
    }
    else
    {
        throw new NotSupportedException("Database unsupported");
    }
    
    StringBuilder sb = new StringBuilder();
    sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, DM_UTENTI.AOO AS AOO, DM_MSG.PSWZIP ");
    sb.Append("FROM DM_MSG INNER JOIN DM_UTENTI ON DM_MSG.ID_MITT = DM_UTENTI.Utente ");
    sb.Append($"WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 ");
    sb.Append("UNION ");
    sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, '' AS AOO, DM_MSG.PSWZIP ");
    sb.Append($"FROM DM_MSG WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND DM_MSG.ID_MITT IS NULL");
    

    Conclusione

    La tua implementazione è corretta per supportare entrambi i database, basta avere _lengthFunction valorizzato a LENGTH o LEN in base al provider. Il codice sembra già strutturato per questo. Assicurati solo che il riconoscimento del tipo _dbConnection sia affidabile.

    Se vuoi che ti aiuti a integrare questo riconoscimento o a refactorare il codice per maggiore flessibilità fammi sapere.

  3. User

    sto avendo questo errore "Errore: ORA-12704: Set di caratteri non corrispondenti"

  4. Assistant

    L'errore ORA-12704: Set di caratteri non corrispondenti in Oracle indica che stai effettuando un'operazione su colonne o stringhe che hanno set di caratteri incompatibili: ad esempio un confronto, un UNION o un join tra colonne che hanno charset o collation diversi.

    Nel tuo caso, l'errore si verifica probabilmente a causa del comando UNION tra due query, in cui le colonne AOO hanno comportamenti differenti:

    • Nella prima parte della query (dove fai INNER JOIN con DM_UTENTI), prendi DM_UTENTI.AOO che è probabilmente di tipo VARCHAR2 con un certo set di caratteri (es. UTF8).
    • Nella seconda parte della query (la select dopo UNION) ritorni una stringa letterale vuota '' AS AOO.

    Oracle in quel caso ha problemi a confrontare / unire colonne che hanno set di caratteri differenti (ad esempio VARCHAR2 vs stringa letterale NVARCHAR2 o viceversa).


    Come risolvere l'errore

    Soluzione più comune: assicurarsi che la stringa letterale nella seconda select del UNION abbia lo stesso tipo SQL e lo stesso set di caratteri della colonna AOO.

    Per esempio:

    • Usa CAST('' AS VARCHAR2(100)) AS AOO oppure
    • Usa TO_CHAR('') AS AOO (anche se è equivalente di fatto a semplice stringa letterale)
    • Oppure usa '' con lo stesso tipo carattere esplicitato, come: '' oppure N'' o '' con specifica set di caratteri

    Applicazione al tuo codice

    La parte da cambiare è questa:

    SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, '' AS AOO, DM_MSG.PSWZIP
    FROM DM_MSG WHERE ...
    

    Cambia in:

    SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, CAST('' AS VARCHAR2(100)) AS AOO, DM_MSG.PSWZIP
    FROM DM_MSG WHERE ...
    

    Oppure, se conosci la lunghezza massima di AOO nella tabella DM_UTENTI, metti quella come dimensione del VARCHAR2.


    Come modificare in C#

    Per aggiungere CAST all’alias AOO nella seconda select, modifica la parte di StringBuilder che costruisce quella query:

    sb.Append("UNION ");
    sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, CAST('' AS VARCHAR2(100)) AS AOO, DM_MSG.PSWZIP ");
    sb.Append($"FROM DM_MSG WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND DM_MSG.ID_MITT IS NULL");
    

    Nota aggiuntiva

    • Questa soluzione funziona solo se stai usando Oracle (o database che supportano CAST con VARCHAR2) e devi prevedere il ramo Oracle.
    • Per SQL Server invece la stringa vuota '' non causa problemi.
    • Quindi, potresti voler fare la costruzione della query condizionata al provider:
    if (_lengthFunction == "LENGTH")
    {
        sb.Append("UNION ");
        sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, CAST('' AS VARCHAR2(100)) AS AOO, DM_MSG.PSWZIP ");
        sb.Append($"FROM DM_MSG WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND DM_MSG.ID_MITT IS NULL");
    }
    else
    {
        sb.Append("UNION ");
        sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, '' AS AOO, DM_MSG.PSWZIP ");
        sb.Append($"FROM DM_MSG WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND DM_MSG.ID_MITT IS NULL");
    }
    

    Riassumendo

    L’errore ORA-12704 nasce perché la colonna AOO è di un certo tipo con un certo charset in una select, mentre nell’altra stai usando una stringa letterale '' senza specificare cast o tipo.

    Risolvilo facendo il cast esplicito della stringa letterale alla colonna AOO in Oracle, come CAST('' AS VARCHAR2(100)).


    Se ti serve, posso aiutarti a fare una versione più robusta per gestire sia Oracle sia SQL Server!

  5. User

    mi puoi riscrivere il metodo in maniera funzionante?

  6. Assistant

    Certamente! Ti riscrivo il metodo completo gestendo in modo robusto la differenza tra Oracle e SQL Server, in particolare:

    • Variabile _lengthFunction impostata in base al tipo di DB.
    • Query costruita in modo diverso per Oracle (cast della stringa vuota AOO con CAST('' AS VARCHAR2(100))) e per SQL Server (semplice '' AS AOO).
    • Uso di INNER JOIN (anziché la vecchia sintassi join con la virgola).
    • Eccezione rilanciata senza perdita dello stack (throw; anziché throw ex;).

    Ecco la versione corretta del metodo:

    public List<dmMsg> loadDM_MSG()
    {
        try
        {
            List<dmMsg> dmMsg = new List<dmMsg>();
    
            // Determina la funzione che calcola la lunghezza, in base al tipo di DB
            string _lengthFunction;
            bool isOracle;
    
            string connectionTypeName = _dbConnection.GetType().Name.ToLower();
    
            if (connectionTypeName.Contains("oracle"))
            {
                _lengthFunction = "LENGTH";
                isOracle = true;
            }
            else if (connectionTypeName.Contains("sqlconnection") || connectionTypeName.Contains("sql"))
            {
                _lengthFunction = "LEN";
                isOracle = false;
            }
            else
            {
                throw new NotSupportedException("Tipo database non supportato");
            }
    
            StringBuilder sb = new StringBuilder();
    
            // Prima select con join su DM_UTENTI e DM_MSG.ID_MITT= DM_UTENTI.Utente
            sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, DM_UTENTI.AOO AS AOO, DM_MSG.PSWZIP ");
            sb.Append("FROM DM_MSG INNER JOIN DM_UTENTI ON DM_MSG.ID_MITT = DM_UTENTI.Utente ");
            sb.Append($"WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 ");
    
            // UNION con seconda select su DM_MSG.ID_MITT IS NULL
            sb.Append("UNION ALL "); // uso UNION ALL per migliori performance se non vogliamo eliminare duplicati
    
            if (isOracle)
            {
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, CAST('' AS VARCHAR2(100)) AS AOO, DM_MSG.PSWZIP ");
            }
            else
            {
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, '' AS AOO, DM_MSG.PSWZIP ");
            }
    
            sb.Append($"FROM DM_MSG WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND (DM_MSG.ID_MITT IS NULL OR DM_MSG.ID_MITT = 0)");
    
            DbCommand command = _dbConnection.CreateCommand();
            command.CommandText = sb.ToString();
            command.CommandType = CommandType.Text;
    
            using (DbDataReader reader = command.ExecuteReader())
            {
                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        var _dmMsgItem = new dmMsg()
                        {
                            _id = MongoDB.Bson.ObjectId.GenerateNewId(),
                            ID = Convert.ToInt32(reader["ID"]),
                            storeDate = Convert.ToDateTime(reader["DATA"]),
                            fileName = reader["FILENAME"].ToString(),
                            cstring = reader["CSTRING"].ToString(),
                            compressionMode = Convert.ToInt32(reader["COMPRESSIONMODE"]),
                            aoo = reader["AOO"].ToString(),
                            pswzip = reader["PSWZIP"].ToString()
                        };
    
                        dmMsg.Add(_dmMsgItem);
                    }
                }
            }
    
            return dmMsg;
    
        }
        catch (Exception)
        {
            // rilancio errore mantenendo lo stack originale
            throw;
        }
    }
    

    Note:

    • Assicurati che _dbConnection sia aperta prima di chiamare questo metodo.
    • Uso UNION ALL per evitare overhead del deduplication: se vuoi UNION usa senza ALL.
    • La dimensione VARCHAR2(100) nel cast è un esempio, sostituisci con la dimensione reale di AOO in DM_UTENTI.
    • Se vuoi, puoi rifinire il rilevamento del tipo di connessione con controlli più precisi sul tipo di _dbConnection.
    • Gestisci eventuale null su colonne se possono presentarsi nel DB (in questo codice si assume che le colonne siano NON NULL).

    Se vuoi posso aiutarti anche con la parte di impostazione della _dbConnection e la gestione del connection string. Fammi sapere!

  7. User

    puoi riscrivermela prendendo esempio da questo "public List loadDM_THUMBNAIL() { try { List dmThumbnail = new List();

        StringBuilder sb = new StringBuilder();
        sb.Append("SELECT DM_THUMBNAIL.ID, DM_THUMBNAIL.KEYID, DM_THUMBNAIL.KEYREVISION, DM_THUMBNAIL.PAGEINDEX, ");
        sb.Append("DM_THUMBNAIL.CREATION_DATE, DM_THUMBNAIL.FILENAME, DM_THUMBNAIL.ORIGINALE, DM_THUMBNAIL.IMPRONTA, ");
        sb.Append("DM_THUMBNAIL.CSTRING, DM_THUMBNAIL.COMPRESSIONMODE, DM_PROFILE.AOO, DM_THUMBNAIL.PSWZIP ");
        sb.Append("FROM DM_THUMBNAIL ");
        sb.Append("INNER JOIN DM_PROFILE ON DM_PROFILE.DOCNUMBER = DM_THUMBNAIL.KEYID ");
        sb.Append($"WHERE DM_THUMBNAIL.CSTRING IS NOT NULL AND {_lengthFunction}(DM_THUMBNAIL.CSTRING) > 0");
    
        DbCommand command = _dbConnection.CreateCommand();
        command.CommandText = sb.ToString();
        command.CommandType = CommandType.Text;
    
        using (DbDataReader reader = command.ExecuteReader())
        {
            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    var _dmThumbnailItem = new dmThumbnail()
                    {
                        _id = MongoDB.Bson.ObjectId.GenerateNewId(),
                        ID = System.Convert.ToInt32(reader["ID"]),
                        docNumber = System.Convert.ToInt32(reader["KEYID"]),
                        pageIndex = System.Convert.ToInt32(reader["PAGEINDEX"]),
                        storeDate = System.Convert.ToDateTime(reader["CREATION_DATE"]),
                        fileName = reader["FILENAME"].ToString(),
                        originale = reader["ORIGINALE"].ToString(),
                        revisione = System.Convert.ToInt32(reader["KEYREVISION"]),
                        impronta = reader["IMPRONTA"].ToString(),
                        cstring = reader["CSTRING"].ToString(),
                        compressionMode = System.Convert.ToInt32(reader["COMPRESSIONMODE"]),
                        aoo = reader["AOO"].ToString(),
                        pswzip = reader["PSWZIP"].ToString()
                    };
    
                    dmThumbnail.Add(_dmThumbnailItem);
                }
            }
        }
    
    
    
        return dmThumbnail;
    
    }
    catch (Exception ex)
    {
        throw ex;
    }
    

    }"?

  8. Assistant

    Certamente! Ti riscrivo il metodo loadDM_MSG seguendo esattamente lo stile e la struttura del metodo loadDM_THUMBNAIL che hai fornito, inclusa la parte in cui usi _lengthFunction e mantenendo la logica per Oracle/SQL Server per il cast della stringa vuota.


    Metodo loadDM_MSG riscritto in stile loadDM_THUMBNAIL

    public List<dmMsg> loadDM_MSG()
    {
        try
        {
            List<dmMsg> dmMsg = new List<dmMsg>();
    
            // Determina la funzione lunghezza e se siamo su Oracle o SQL Server
            string _lengthFunction;
            bool isOracle;
    
            string connectionTypeName = _dbConnection.GetType().Name.ToLower();
    
            if (connectionTypeName.Contains("oracle"))
            {
                _lengthFunction = "LENGTH";
                isOracle = true;
            }
            else if (connectionTypeName.Contains("sqlconnection") || connectionTypeName.Contains("sql"))
            {
                _lengthFunction = "LEN";
                isOracle = false;
            }
            else
            {
                throw new NotSupportedException("Tipo database non supportato");
            }
    
            StringBuilder sb = new StringBuilder();
    
            // Prima parte della query: join con DM_UTENTI via ID_MITT
            sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, DM_UTENTI.AOO AS AOO, DM_MSG.PSWZIP ");
            sb.Append("FROM DM_MSG ");
            sb.Append("INNER JOIN DM_UTENTI ON DM_MSG.ID_MITT = DM_UTENTI.Utente ");
            sb.Append($"WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 ");
    
            // UNION ALL con seconda select senza ID_MITT che effettua il cast su Oracle
            sb.Append("UNION ALL ");
    
            if (isOracle)
            {
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, CAST('' AS VARCHAR2(100)) AS AOO, DM_MSG.PSWZIP ");
            }
            else
            {
                sb.Append("SELECT DM_MSG.ID, DM_MSG.DATA, DM_MSG.FILENAME, DM_MSG.CSTRING, DM_MSG.COMPRESSIONMODE, '' AS AOO, DM_MSG.PSWZIP ");
            }
    
            sb.Append($"FROM DM_MSG ");
            sb.Append($"WHERE DM_MSG.CSTRING IS NOT NULL AND {_lengthFunction}(DM_MSG.CSTRING) > 0 AND (DM_MSG.ID_MITT IS NULL OR DM_MSG.ID_MITT = 0)");
    
            DbCommand command = _dbConnection.CreateCommand();
            command.CommandText = sb.ToString();
            command.CommandType = CommandType.Text;
    
            using (DbDataReader reader = command.ExecuteReader())
            {
                if (reader.HasRows)
                {
                    while (reader.Read())
                    {
                        var _dmMsgItem = new dmMsg()
                        {
                            _id = MongoDB.Bson.ObjectId.GenerateNewId(),
                            ID = System.Convert.ToInt32(reader["ID"]),
                            storeDate = System.Convert.ToDateTime(reader["DATA"]),
                            fileName = reader["FILENAME"].ToString(),
                            cstring = reader["CSTRING"].ToString(),
                            compressionMode = System.Convert.ToInt32(reader["COMPRESSIONMODE"]),
                            aoo = reader["AOO"].ToString(),
                            pswzip = reader["PSWZIP"].ToString()
                        };
    
                        dmMsg.Add(_dmMsgItem);
                    }
                }
            }
    
            return dmMsg;
        }
        catch (Exception ex)
        {
            throw ex; // come nel tuo esempio, anche se idealmente meglio 'throw;'
        }
    }
    

    Cosa ho fatto:

    • Uso _lengthFunction come da tuo esempio, impostandolo in base a _dbConnection.
    • Costruzione della query con StringBuilder come nel loadDM_THUMBNAIL.
    • Uso di INNER JOIN standard.
    • Nella seconda SELECT del UNION ALL uso il cast CAST('' AS VARCHAR2(100)) AS AOO solo se Oracle, altrimenti semplice '' AS AOO.
    • Copiato lo stile di lettura e creazione degli oggetti dmMsg.
    • Mantenuto la gestione try/catch uguale al tuo esempio.

    Se vuoi, posso aiutarti anche a rendere il metodo più robusto, ad esempio con rilancio di eccezioni migliore (throw;) o aggiungendo i controlli su eventuali DBNull in lettura. Fammi sapere!