In questa lezione andremo avanti ad analizzare gli oggetti grafici disponibili in Visual Studio C# Express 2010 ed in particolar modo le WinForms.

Come sempre per una migliore visione vi consiglio di vedere il video a tutto schermo cliccando sul bottone di youtube con le 4 frecce.

1 Lezione: Come Iniziare ?

2 Lezione: Hello World

Domande?

1 Lezione: [Video] Impara a programmare in C#: Come Iniziare ?

Pubblicherò ogni nuova lezione a metà settimana (con questa lezione sono andato lungo perchè ho avuto problemi tecnici di pubblicazione del video ed un virus intestinale che mi ha messo KO) in cui affronterò un passo per volta tutte le tappe per imparare a programmare in Visual Studio C#. Dopo il salto troverete i Video/ScreenCast della prima lezione.

1 PARTE

2 PARTE

Per scaricare Visual Studio Express ecco il link: http://www.microsoft.com/express/

Dalla mia esperienza, nella progettazione di un database fin dall’inizio si dà una struttura piuttosto rigida. Dopo aver definito le tabelle e creato alcune stored procedure, gli sviluppatori iniziano a lavorare sulle loro applicazioni cercando di adattare l’applicazione alle condizioni esistenti del DB e spesso essi devono raggiungere compromessi perché una piccola modifica a una tabella di DB può rovinare tutta una catena di relazioni tra tabelle.

La tecnica di cui vorrei parlare è chiamata ORM, o object-relational mapping . Al suo centro è l’idea che specifiche tipologie di informazioni o proprietà possono essere facilmente convertite in valori che possono essere memorizzati in un database (nella maggior parte dei casi, basato su SQL) – dunque, semplici (scalari), tipi di valore.

Per fare un esempio, se si dispone di un oggetto di tipo di veicolo che è un insieme di proprietà (ad esempio, peso, velocità, colore), non è possibile salvarlo direttamente in un database SQL come un oggetto – è necessario convertire ogni singola proprietà in uno tipo semplice e memorizzarli nel contesto di una entità (riga) che rappresenterà l’oggetto del veicolo.

Facciamo un esempio di come questo viene fatto in C#, voglio creare una classe molto semplice che possa rappresentare un modello di dati e utilizza LINQ to SQL per creare una base di dati intorno ad esso. E sebbene LINQ to SQL viene lentamente sostituito da Entity Framework, per questo breve tutorial sarà sufficiente per acquisire familiarità con alcuni dei concetti di base.

Ecco la classe base che rappresenta un veicolo in cui VIN è l’identificativo univoco:

public class Veicolo
{
    public string VIN { get; internal set; }
    public string Tipo { get; set; }
    public string Nome { get; set; }
    public DateTime DataFabbricazione { get; set; }
}

Prima di proseguire, assicuratevi di avere i corretti riferimenti:

using System.Data.Linq;
using System.Data.Linq.Mapping;

Ecco come viene trasformata la classe per il database, che è quella che effettivamente useremo nel codice:

[Table(Name="Veicoli")]
public class Veicolo
{
    [Column(IsPrimaryKey=true,CanBeNull=false,IsDbGenerated=false)]
    public string VIN { get; internal set; }
    [Column]
    public string Tipo { get; set; }
    [Column]
    public string Nome { get; set; }
    [Column]
    public DateTime DataFabbricazione { get; set; }
}

Gli attributi definiscono la struttura della tabella. Per esempio, definisco il nome della tabella quando dichiaro la classe, questo non è obbligatorio, ma è consigliabile per avere delle regole comuni di progettazione. Lo stesso concetto vale per le colonne, il cui nome viene preso direttamente dal nome delle proprietà della classe, quindi non devo impostare in modo esplicito il loro nome.

VIN sarà la chiave primaria – è unico, quindi è perfetto per una chiave primaria. Inoltre, non viene generato dal DB e non può essere nullo. Se usassi un semplice campo ID per la chiave primaria, allora non ci sarebbe assolutamente nessun problema nel fissare i valori perchè verrebbero generati direttamente dal DB con un meccanismo di auto-incremento.

Così ora c’è una struttura. Come diventa un DB? Prima di tutto, la maggior parte degli oggetti di LINQ to SQL girano intorno a DataContext che è la connessione dati . E ‘l’anello di congiunzione tra l’applicazione e la database. Dato che ho già una struttura di base, posso creare un’istanza di DataContext che si connette al mio database (con una stringa di connessione esistente):

DataContext dc = new DataContext("Data Source=(local);Integrated Security=SSPI;Initial Catalog=VEICOLI_DB;");

Ora che c’è una connessione, è possibile passare una tabella all’istanza di DataContext:

dc.GetTable<Veicolo>();

Questa istruzione ritornerà come risultato il set di tabelle che sono basate sull’entità veicolo. Siccome non ci sono tabelle definite sull’entità passata, una tabella verrà creata secondo le regole definite dagli attributi. Alla fine io devo solo fare questo per creare il database:

dc.CreateDatabase();

Anche se il database definito nella stringa di connessione non esiste, sarà creato. Ora, diamo uno sguardo al server per vedere se il database effettivamente c’è:

Come si può vedere, l’utilizzo di un ORM consente di risparmiare tempo (e un pò di righe di codice), quando si tratta di creare un DB in base alle esigenze specifiche di un applicazione. Naturalmente il maggior vantaggio si otterrà con progetti complessi, questa semplificazione porta alcune volte gli sviluppatori a commettere degli errori come la non ottimizzazione delle query.

Continua a seguirmi perchè prossimamente approfondirò l’argomento, e tu hai mai usato LINQ to SQL in C#?

In questo esempio un metodo verifica la presenza di una divisione per zero e rileva l’errore. Senza la gestione delle eccezioni, il programma verrebbe chiuso con un errore simile al seguente: DivideByZeroException non è stata gestita.

int DivisioneSicura(int x, int y)
{
    try
    {
        return (x / y);
    }
    catch (System.DivideByZeroException dbz)
    {
        System.Console.WriteLine("Attenzione divisione per zero!!!");

        // Stampo il messaggio di errore
        System.Console.WriteLine(dbz.Message);

        // Stampo il numero di riga del sorgente dove si trova l'errore
        System.Console.WriteLine(dbz.StackTrace);

        return 0;
    }
}

Cenni preliminari sulle eccezioni

Le eccezioni dispongono delle seguenti proprietà:

• Quando nell’applicazione si verifica una circostanza eccezionale, ad esempio una divisione per zero o un problema di memoria insufficiente, viene generata un’eccezione.
• Utilizzare un blocco try intorno alle istruzioni che potrebbero generare eccezioni.
• Quando si verifica un’eccezione all’interno del blocco try, il flusso di controllo passa immediatamente a un gestore eccezioni associato, se presente.
• Se per una determinata eccezione non sono presenti gestori, l’esecuzione del programma verrà interrotta con un messaggio di errore.
• Se un blocco catch definisce una variabile dell’eccezione, è possibile utilizzarlo per ottenere ulteriori informazioni sul tipo di eccezione che si è verificata.
• Le azioni che possono generare un’eccezione vengono eseguite con la parola chiave try.
• Un gestore eccezioni è un blocco di codice che viene eseguito quando si verifica un’eccezione. Per la definizione di un gestore eccezioni, in C# viene utilizzata la parola chiave catch.
• Le eccezioni possono essere generate in modo esplicito da un programma mediante la parola chiave throw.
• Gli oggetti eccezione contengono informazioni dettagliate sull’errore, tra cui lo stato dello stack di chiamate e una descrizione dell’errore, quindi per stampare la descrizione dell’errore uso l’istruzione System.Console.WriteLine(dbz.Message); infine per stampare il numero di riga dove si trova l’errore System.Console.WriteLine(dbz.StackTrace);

Fonte: msdn.microsoft.com