C# ADO.NET: mappare le proprietà di un oggetto in un DataRow e aggiungerlo a un DataTable

Il seguente frammento di codice in C# illustra una tecnica, utilizzando ADO.NET, per mappare i dati presenti nelle proprietà di un oggetto nelle colonne di un DataTable.

In particolare, viene creato un oggetto di tipo DataRow nel quale vengono copiati i valori delle proprietà dell'oggetto che hanno un nome corrispondente a quello delle colonne presenti nel DataTable.

La classe di esempio

Di seguito viene riportata la classe che utilizzeremo nell'esempio:

 

C#

   class Anagrafica

   {

       public string Nome { get; set; } = string.Empty;

 

       public string Cognome { get; set; } = string.Empty;

 

       public DateTime DataNascita { get; set; }

 

 

 

   }

Il DataTable

Per l'esempio utilizziamo un oggetto di tipo DataTable:

C#

private DataTable dttDati = new DataTable();

La funzione per il mapping

La seguente funzione si occupa di copiare nel DataRow i valori presenti nelle proprietà dell'oggetto.

Per ottenere le proprietà dell'oggetto viene utilizzata la Reflection tramite il metodo GetProperties().

Per ogni proprietà viene verificato se nel DataTable esiste una colonna con lo stesso nome. In caso affermativo, il valore della proprietà viene assegnato alla relativa colonna del DataRow.

C#

private void MappaDtoObjectInDataRow(object dto, DataRow r)

 {

     foreach (var prop in dto.GetType().GetProperties())

     {

         if (dttDati.Columns.Contains(prop.Name))

         {

             r[prop.Name] = prop.GetValue(dto) ?? DBNull.Value;

         }

     }

 }

 

In questo modo, ad esempio, la proprietà Nome dell'oggetto viene associata alla colonna Nome del DataTable, la proprietà Cognome alla colonna Cognome e così via.

Esempio di utilizzo

Di seguito viene mostrato un esempio di utilizzo della funzione, ad esempio all'interno dell'evento Load di una Form oppure nell'evento Click di un pulsante.

Per prima cosa vengono definite le colonne del DataTable:

C#

dttDati.Columns.Add(new DataColumn("Nome"));

 dttDati.Columns.Add(new DataColumn("Cognome"));

 dttDati.Columns.Add(new DataColumn("DataNascita"));

Successivamente viene creato un oggetto Anagrafica:

C#

Anagrafica nominativo = new Anagrafica

 {

     Nome = "Emanuele",

     Cognome = "Mattei",

     DataNascita = DateTime.Now

 

 };

A questo punto viene creato un nuovo DataRow utilizzando il metodo NewRow() del DataTable:

C#

DataRow riga = dttDati.NewRow();

Il metodo MappaDtoObjectInDataRow() viene quindi utilizzato per copiare nel DataRow i valori presenti nelle proprietà dell'oggetto:

C#

MappaDtoObjectInDataRow(nominativo, riga);

Infine, il DataRow viene aggiunto al DataTable:

C#

dttDati.Rows.Add(riga);

Il risultato è quindi un DataTable nel quale i valori dell'oggetto Anagrafica sono stati associati alle colonne aventi lo stesso nome delle relative proprietà.

Download gioco gratuito SpecialForce Remaster

 

SpecialForce Remaster è uno sparatutto in prima persona (FPS) disponibile gratuitamente per PC Windows sulla piattaforma Epic Games Store.

Il gioco propone modalità multiplayer a squadre, combattimenti frenetici e diverse modalità di gioco, tra cui Team Deathmatch, Free for All e modalità a obiettivi. È disponibile con testi e audio in inglese

Per maggiori informazioni e download, visitate il seguente sito https://store.epicgames.com/p/special-force-remastered-8989d7

Error 19 "UNIQUE constraint failed" con SQLite ed Entity Framework Core C#

Quando si sviluppano applicazioni utilizzando il database SQLite, Entity Framework Core e il linguaggio C#, durante l'inserimento dei dati può verificarsi un errore di questo tipo:

Error 19: 'UNIQUE constraint failed: NomeTabella.Campo'.

Questo errore indica che si sta tentando di inserire un valore già presente in una colonna sulla quale è stato definito un vincolo UNIQUE oppure che viene utilizzata come chiave primaria.

Nel caso in cui il campo sia una chiave primaria numerica che deve essere generata automaticamente da SQLite, è opportuno verificare innanzitutto che la relativa colonna sia stata definita correttamente, ad esempio:

NomeCampo INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL

È inoltre importante verificare la configurazione del modello nel DbContext, all'interno del metodo OnModelCreating, affinché Entity Framework Core sappia che il valore della chiave viene generato al momento dell'inserimento.

Ad esempio:

C#

modelBuilder.Entity<NomeTabella>(entity =>
{
    entity.HasKey(e => e.IdCampoChiaveContatore);

    entity.Property(e => e.IdCampoChiaveContatore).ValueGeneratedOnAdd();
    entity.Property(e => e.CampoDate).HasColumnType("DATETIME");
});

 

In questo modo, IdCampoChiaveContatore viene configurato come chiave il cui valore viene generato durante l'inserimento del record.

Se, nonostante questa configurazione, compare l'errore UNIQUE constraint failed, è opportuno verificare anche il valore che l'applicazione sta effettivamente tentando di inserire: se viene assegnato manualmente un valore già esistente alla chiave primaria, SQLite segnalerà comunque una violazione del vincolo UNIQUE.

 

C# Entity Framework Core e SQLite: errore "SQLite Error 14: unable to open database file"

Quando si utilizza un database SQLite con Entity Framework Core, può capitare di visualizzare un errore simile al seguente:

SQLite Error 14: 'unable to open database file'.

Una delle cause più comuni è che il percorso specificato per il database non sia corretto oppure che il file .db non si trovi nella directory in cui l'applicazione lo sta cercando.

Se il database viene inserito all'interno di una cartella del progetto, è importante assicurarsi che il file venga copiato nella directory di output durante la compilazione. Nelle finestra delle proprietà del file .db, impostare quindi l'opzione "Copia se più recente" alla voce "Copia nella directory di output".

In questo modo, il database verrà copiato nella directory di output dell'applicazione e sarà disponibile quando l'applicazione viene eseguita.

È inoltre opportuno verificare che la directory indicata nel connection string esista e che l'applicazione disponga dei permessi necessari per accedere al file.

C# Filtrare i record di un DataTable in base alla selezione di un DataGridView

 In questo frammento di codice C# vediamo come, selezionando una riga di un controllo DataGridView, sia possibile recuperare il valore di un campo chiave e utilizzarlo per filtrare i record contenuti in un DataTable.

In questo modo vengono restituiti solamente i record che hanno nel campo chiave lo stesso valore dell'ID della riga selezionata.

Il DataGridView deve contenere una colonna ID nascosta, che utilizzeremo per effettuare la condizione di filtro.

Una volta applicato il filtro, i dati vengono ordinati e proiettati nei campi necessari, per poi essere assegnati come DataSource a un secondo DataGridView.

Aggiungere lo spazio dei nomi System.Linq

C#

private void datagridview1_SelectionChanged(object sender, EventArgs e)

 {

     try

     {

         if (datagridview1.CurrentRow == null || datagridview1.CurrentRow.IsNewRow)

             return;

         

         var IdRecord = datagridview1.CurrentRow.Cells["ColonnaIDNascosta"].Value;

         if (IdRecord  == null || IdRecord  == DBNull.Value)

             return;

          

         var righeFiltrate = dataTableDati.AsEnumerable()

                 .Where(r => (r.Field<int?>("CampoChiave ") ?? -1) == Convert.ToInt32(IdRecord ))

                 .OrderBy(r => Convert.ToString(r["CampoDataTable"]))

                 .Select(r => new

                 {

                     Campo = Convert.ToString(r["CampoA"]),

                     CampoB = Convert.ToString(r["CampoB "]),

                     CampoUnionte =

                         $"{Convert.ToString(r["CampoC "])}-{Convert.ToString(r["CampoD"])}",

                     CampioC = Convert.ToString(r["CampoE"])

                 })

                 .ToList();

 

         datagridview2.DataSource = righeFiltrate;

     }

     catch (Exception ex)

     {

          

         Messagebox.Show("Impossibile caricare i dati.", “Errore”, MessageBoxButtons.OK,

            MessageBoxIcon.Error);

     }

 }

C# realizzare una galleria fotografica con .NET 10 e Windows Forms

Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/microsoft-net-framework/csharp-realizzare-galleria-fotografica-dotnet-10-windows-forms

In questo articolo vedremo come creare, utilizzando l’ultima versione di .NET, attualmente la 10, una galleria fotografica in ambiente Windows Forms.

Il progetto illustra una tecnica per realizzare una galleria fotografica in grado di visualizzare diverse immagini, trasformando l'applicazione in una sorta di cornice fotografica digitale.

Il tutto verrà realizzato senza utilizzare librerie di terze parti, ricorrendo esclusivamente alle funzionalità messe a disposizione da .NET e Windows Forms, come mostrato nell'esempio seguente.

Per prima cosa, creiamo una cartella, chiamata ad esempio "galleria", nella quale inseriamo 10 o più immagini in formato JPG.

Creazione del progetto

Creiamo un nuovo progetto di tipo Windows Forms, selezionando "App Windows Forms" e utilizzando l'ultima versione di .NET disponibile. Al momento della stesura dell'articolo, la versione corrente è .NET 10.

Dopo aver creato il progetto, aggiungiamo alla form i seguenti controlli:

un controllo PictureBox, che possiamo ingrandire in modo da occupare buona parte della form. Impostiamo la proprietà Name su pcbGalleria e la proprietà SizeMode su Zoom;

un controllo Label, con la proprietà Text impostata su Percorso della cartella delle immagini;

un controllo TextBox, con la proprietà Name impostata su TxtPercorsoImmagini e la proprietà ReadOnly impostata su true;

un controllo NumericUpDown, con la proprietà Name impostata su nudSecondi, la proprietà Increment impostata su 1000, la proprietà Maximum impostata su 10000 e la proprietà Minimum impostata su 1000;

un controllo Button, posizionato accanto alla casella di testo, con la proprietà Text impostata su ... e la proprietà Name impostata su BtnPercorsoImmagini;

un secondo controllo Button, posizionato sotto la casella di testo, con la proprietà Text impostata su Avvia e la proprietà Name impostata su BtnAvvia;

infine, un controllo Timer.

Il risultato dovrebbe essere simile a quello mostrato nella Figura 1.

Figura 1 – La form con i vari controlli

A questo punto la nostra form è stata creata. Non ci resta che scrivere il codice necessario per realizzare la galleria fotografica.

Stesura del codice

Facciamo doppio clic sul pulsante "BtnTrovaCartella" per aprire la visualizzazione del codice e generare automaticamente il gestore dell'evento Click del pulsante.

Di seguito riportiamo il frammento di codice che permette di selezionare una cartella presente sul proprio PC.

C#

private void BtnTrovaCartella_Click(object sender, EventArgs e)

 {

     try

     {

         using (FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog())

         {

             folderBrowserDialog.Description = "Seleziona la cartella dove si trovano i file Immagine";

             folderBrowserDialog.RootFolder = Environment.SpecialFolder.Desktop;

             if (folderBrowserDialog.ShowDialog() == DialogResult.OK)

             {

                 // Imposto il percorso selezionato nella casella di testo

                 TxtPercorsoImmagini.Text = folderBrowserDialog.SelectedPath;

             }

         }

 

 

 

 

     }

     catch (Exception)

     {

 

         throw;

     }

 }

 

Sempre all'interno della form, aggiungiamo due variabili: un array di tipo string, che conterrà i percorsi dei file immagine da visualizzare, e una variabile di tipo int, che verrà utilizzata per memorizzare l'indice del file attualmente visualizzato.

Inseriamo le seguenti dichiarazioni all'interno della classe della form, subito dopo la dichiarazione della classe:

C#

private string[] imgFiles;

 

private int indiceCorrente = 0;

Sempre all'interno della form, scriviamo una funzione che individua, nella cartella selezionata, tutti i file immagine e ne memorizza i percorsi nell'array imgFiles.

Di seguito il codice della funzione.

C#

private void LoadImagesDaCartella(string cartella)

{

    try

    {

        if (!Directory.Exists(cartella))

        {

            Directory.CreateDirectory(cartella);

        }

 

        // Filtra solo formati immagine comuni

 

         imgFiles = Directory.GetFiles(cartella)

     .Where(file =>

         file.EndsWith(".jpg", StringComparison.OrdinalIgnoreCase) ||

         file.EndsWith(".jpeg", StringComparison.OrdinalIgnoreCase) ||

         file.EndsWith(".png", StringComparison.OrdinalIgnoreCase) ||

         file.EndsWith(".bmp", StringComparison.OrdinalIgnoreCase) ||

         file.EndsWith(".gif", StringComparison.OrdinalIgnoreCase)

     )

     .ToArray();

 

 

 

    }

    catch (Exception ex)

    {

        MessageBox.Show($"Errore nel caricamento immagini: {ex.Message}", "Errore", MessageBoxButtons.OK, MessageBoxIcon.Error);

        imgFiles = Array.Empty<string>();

    }

}

 

Passiamo nuovamente alla visualizzazione grafica e facciamo doppio clic sul controllo Timer, in modo da aprire il gestore dell'evento Tick.

All'interno di questo evento gestiamo la visualizzazione delle immagini utilizzando la variabile indiceCorrente, che indica l'elemento corrente dell'array imgFiles.

In questo modo, allo scadere dell'intervallo impostato nel Timer, viene visualizzata nel controllo PictureBox l'immagine successiva. Una volta raggiunta l'ultima immagine, la visualizzazione riparte dalla prima.

Di seguito riportiamo il frammento di codice relativo a queste operazioni.

C#

private void timer1_Tick(object sender, EventArgs e)

{

    try

    {

        indiceCorrente = (indiceCorrente + 1) % imgFiles.Length;

        pcbGalleria.Image?.Dispose(); // Libera la precedente immagine

        pcbGalleria.Image = Image.FromFile(imgFiles[indiceCorrente]);

    }

    catch (Exception ex)

    {

        timer1.Stop();

        MessageBox.Show($"Errore durante il caricamento dell'immagine: {ex.Message}", "Errore", MessageBoxButtons.OK, MessageBoxIcon.Error);

    }

}

 

Passiamo nuovamente alla visualizzazione grafica e facciamo doppio clic sul pulsante BtnAvvia, in modo da aprire la visualizzazione del codice relativo all'evento Click del pulsante.

All'interno di questo evento impostiamo l'intervallo del controllo Timer e richiamiamo la funzione che individua i file immagine presenti nella cartella selezionata, memorizzandone i percorsi nell'array imgFiles.

Se vengono trovate una o più immagini, avviamo il Timer e la galleria può iniziare a visualizzare le immagini.

Di seguito riportiamo il codice relativo a queste operazioni.

C#

 private void BtnAvvia_Click(object sender, EventArgs e)

 {

     if (TxtPercorsoImmagini.Text.Trim() == "")

     {

         MessageBox.Show($"Seleziona un percorso dove sono presenti le immagini", "Gallery", MessageBoxButtons.OK, MessageBoxIcon.Information);

         return;

     }

           

     LoadImagesDaCartella(TxtPercorsoImmagini.Text);

     if (imgFiles.Length > 0)

     {

         indiceCorrente = 0;

 

         pcbGalleria.Image?.Dispose();

         pcbGalleria.Image = Image.FromFile(imgFiles[indiceCorrente]);

 

         timer1.Interval = (int)nudSecondi.Value;

         timer1.Start();

 

     }

     else

         MessageBox.Show("Nessuna immagine trovata nella cartella 'Images'.", "Errore", MessageBoxButtons.OK, MessageBoxIcon.Warning);

 }

Il risultato finale sarà simile a quello mostrato nell'immagine seguente.

Figura 2 – Il risultato della galleria

Conclusioni

In questo articolo abbiamo visto come creare una semplice cornice digitale utilizzando .NET e Windows Forms.

Con poche righe di codice possiamo trasformare il nostro PC o un monitor in una cornice fotografica digitale, in grado di visualizzare automaticamente le nostre immagini.

Possiamo così utilizzare il progetto per mostrare le fotografie delle vacanze appena trascorse, dei momenti più belli trascorsi con le persone care oppure semplicemente quelle immagini che vogliamo tenere sempre a portata di vista.