C# Language
Accesso ai database

Connessioni ADO.NET

Le connessioni ADO.NET sono uno dei modi più semplici per connettersi a un database da un'applicazione C #. Si basano sull'utilizzo di un provider e di una stringa di connessione che punta al database per eseguire query contro.

Classi di provider di dati comuni

Molte delle seguenti sono classi che vengono comunemente utilizzate per interrogare i database e i relativi spazi dei nomi:

• SqlConnection , SqlCommand , SqlDataReader di System.Data.SqlClient
• OleDbConnection , OleDbCommand , OleDbDataReader di System.Data.OleDb
• MySqlConnection , MySqlCommand , MySqlDbDataReader di MySql.Data

Tutti questi sono comunemente usati per accedere ai dati tramite C # e verranno comunemente riscontrati durante la creazione di applicazioni incentrate sui dati. FooDataReader si può aspettare che molte altre classi che non sono menzionate che implementano le stesse FooConnection , FooCommand , FooDataReader si comportino allo stesso modo.

Modello di accesso comune per connessioni ADO.NET

Un modello comune che può essere utilizzato quando si accede ai dati tramite una connessione ADO.NET potrebbe essere il seguente:

// This scopes the connection (your specific class may vary)
using(var connection = new SqlConnection("{your-connection-string}")
{
    // Build your query
    var query = "SELECT * FROM YourTable WHERE Property = @property");
    // Scope your command to execute
    using(var command = new SqlCommand(query, connection))
    {
         // Open your connection
         connection.Open();

         // Add your parameters here if necessary

         // Execute your query as a reader (again scoped with a using statement)
         using(var reader = command.ExecuteReader())
         {
               // Iterate through your results here
         }
    }
}

O se stavi semplicemente eseguendo un semplice aggiornamento e non avessi bisogno di un lettore, si applicherebbe lo stesso concetto di base:

using(var connection = new SqlConnection("{your-connection-string}"))
{
     var query = "UPDATE YourTable SET Property = Value WHERE Foo = @foo";
     using(var command = new SqlCommand(query,connection))
     {
          connection.Open();
          
          // Add parameters here
          
          // Perform your update
          command.ExecuteNonQuery();
     }
}

È anche possibile programmare contro una serie di interfacce comuni e non doversi preoccupare delle classi specifiche del provider. Le interfacce principali fornite da ADO.NET sono:

• IDbConnection - per la gestione delle connessioni del database
• IDbCommand - per l'esecuzione di comandi SQL
• IDbTransaction - per la gestione delle transazioni
• IDataReader - per leggere i dati restituiti da un comando
• IDataAdapter - per il channeling dei dati da e verso i set di dati

var connectionString = "{your-connection-string}";
var providerName = "{System.Data.SqlClient}"; //for Oracle use "Oracle.ManagedDataAccess.Client"
//most likely you will get the above two from ConnectionStringSettings object

var factory = DbProviderFactories.GetFactory(providerName);

using(var connection = new factory.CreateConnection()) {
    connection.ConnectionString = connectionString;
    connection.Open();

    using(var command = new connection.CreateCommand()) {
        command.CommandText = "{sql-query}";    //this needs to be tailored for each database system

        using(var reader = command.ExecuteReader()) {
            while(reader.Read()) {
                ...
            }
        }
    }
}

Entity Framework Connections

Entity Framework espone le classi di astrazione utilizzate per interagire con i database sottostanti sotto forma di classi come DbContext . Questi contesti generalmente sono costituiti da proprietà DbSet<T> che espongono le raccolte disponibili che possono essere interrogate:

public class ExampleContext: DbContext 
{ 
    public virtual DbSet<Widgets> Widgets { get; set; } 
}

Lo stesso DbContext gestirà le connessioni con i database e in genere leggerà i dati della stringa di connessione appropriata da una configurazione per determinare come stabilire le connessioni:

public class ExampleContext: DbContext 
{ 
    // The parameter being passed in to the base constructor indicates the name of the 
    // connection string
    public ExampleContext() : base("ExampleContextEntities")
    {
    }

    public virtual DbSet<Widgets> Widgets { get; set; } 
}

Esecuzione di query di Entity Framework

L'esecuzione effettiva di una query di Entity Framework può essere abbastanza semplice e richiede semplicemente di creare un'istanza del contesto e quindi utilizzare le proprietà disponibili su di essa per estrarre o accedere ai dati

using(var context = new ExampleContext())
{
      // Retrieve all of the Widgets in your database
      var data = context.Widgets.ToList();
}

Entity Framework fornisce inoltre un ampio sistema di tracciabilità delle modifiche che può essere utilizzato per gestire le voci di aggiornamento all'interno del database semplicemente chiamando il metodo SaveChanges() per inviare modifiche al database:

using(var context = new ExampleContext())
{
      // Grab the widget you wish to update
      var widget = context.Widgets.Find(w => w.Id == id);
      // If it exists, update it
      if(widget != null)
      {
           // Update your widget and save your changes
           widget.Updated = DateTime.UtcNow;
           context.SaveChanges();
      }
}

Stringhe di connessione

Una stringa di connessione è una stringa che specifica le informazioni su una particolare fonte di dati e come procedere per connettersi ad essa memorizzando credenziali, posizioni e altre informazioni.

Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;

Memorizzazione della stringa di connessione

In genere, una stringa di connessione verrà archiviata in un file di configurazione (come app.config o web.config all'interno di applicazioni ASP.NET). Di seguito è riportato un esempio di come potrebbe apparire una connessione locale all'interno di uno di questi file:

<connectionStrings> 
   <add name="WidgetsContext" providerName="System.Data.SqlClient"  connectionString="Server=.\SQLEXPRESS;Database=Widgets;Integrated Security=True;"/> 
</connectionStrings>

<connectionStrings> 
   <add name="WidgetsContext" providerName="System.Data.SqlClient"  connectionString="Server=.\SQLEXPRESS;Database=Widgets;Integrated Security=SSPI;"/> 
</connectionStrings>

Ciò consentirà alla tua applicazione di accedere alla stringa di connessione in modo programmatico tramite WidgetsContext . Sebbene sia Integrated Security=SSPI e Integrated Security=True svolgono la stessa funzione; Integrated Security=SSPI è preferito poiché funziona con entrambi i provider SQLClient e OleDB, dove come Integrated Security=true genera un'eccezione quando utilizzato con il provider OleDb.

Connessioni diverse per provider diversi

Ogni fornitore di dati (SQL Server, MySQL, Azure, ecc.) Presenta il proprio aroma di sintassi per le stringhe di connessione ed espone diverse proprietà disponibili. ConnectionStrings.com è una risorsa incredibilmente utile se non sei sicuro di come dovrebbe essere il tuo.