C# Language
Zugriff auf Datenbanken

ADO.NET-Verbindungen

ADO.NET-Verbindungen sind eine der einfachsten Methoden, um von einer C # -Anwendung aus eine Verbindung zu einer Datenbank herzustellen. Sie sind auf die Verwendung eines Providers und einer Verbindungszeichenfolge angewiesen, die auf Ihre Datenbank verweist, um Abfragen auszuführen.

Allgemeine Datenanbieter-Klassen

Viele der folgenden Klassen werden häufig zum Abfragen von Datenbanken und den zugehörigen Namespaces verwendet:

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

Alle diese Optionen werden im Allgemeinen für den Zugriff auf Daten über C # verwendet. Sie werden häufig in gebäudedatenzentrierten Anwendungen angetroffen. Von vielen anderen Klassen, die nicht erwähnt werden und die dieselben Klassen FooConnection , FooCommand und FooDataReader FooCommand , kann erwartet werden, dass sie sich genauso verhalten.

Allgemeines Zugriffsmuster für ADO.NET-Verbindungen

Ein allgemeines Muster, das beim Zugriff auf Ihre Daten über eine ADO.NET-Verbindung verwendet werden kann, könnte wie folgt aussehen:

// 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
         }
    }
}

Oder wenn Sie nur ein einfaches Update durchführen und keinen Leser benötigen, würde dasselbe Grundkonzept gelten:

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();
     }
}

Sie können sogar für eine Reihe allgemeiner Schnittstellen programmieren und müssen sich nicht um die anbieterspezifischen Klassen kümmern. Die von ADO.NET bereitgestellten Kernschnittstellen sind:

• IDbConnection - zum Verwalten von Datenbankverbindungen
• IDbCommand - zum Ausführen von SQL-Befehlen
• IDbTransaction - zum Verwalten von Transaktionen
• IDataReader - zum Lesen von Daten, die von einem Befehl zurückgegeben werden
• IDataAdapter - zum Weiterleiten von Daten zu und von Datensätzen

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-Verbindungen

Entity Framework macht Abstraktionsklassen DbContext , die zur Interaktion mit zugrunde liegenden Datenbanken in Form von Klassen wie DbContext . Diese Kontexte bestehen im Allgemeinen aus DbSet<T> -Eigenschaften, die die verfügbaren Sammlungen DbSet<T> , die abgefragt werden können:

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

Der DbContext selbst übernimmt das Herstellen der Verbindungen mit den Datenbanken und liest im Allgemeinen die entsprechenden Verbindungszeichenfolgendaten aus einer Konfiguration, um zu bestimmen, wie die Verbindungen hergestellt werden:

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; } 
}

Ausführen von Entity Framework-Abfragen

Das Ausführen einer Entity Framework-Abfrage kann sehr einfach sein. Sie müssen lediglich eine Instanz des Kontexts erstellen und dann die verfügbaren Eigenschaften für den Abruf oder Zugriff auf Ihre Daten verwenden

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

Entity Framework bietet auch ein umfangreiches System zur Änderungsnachverfolgung, mit dem Sie die Aktualisierung von Einträgen in Ihrer Datenbank abwickeln können, indem Sie einfach die SaveChanges() -Methode aufrufen, um Änderungen in die Datenbank zu verschieben:

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();
      }
}

Verbindungszeichenfolgen

Eine Verbindungszeichenfolge ist eine Zeichenfolge, die Informationen zu einer bestimmten Datenquelle und zum Herstellen einer Verbindung zu ihr angibt, indem Anmeldeinformationen, Speicherorte und andere Informationen gespeichert werden.

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

Speichern der Verbindungszeichenfolge

In der Regel wird eine Verbindungszeichenfolge in einer Konfigurationsdatei (z. B. app.config oder web.config in ASP.NET-Anwendungen) gespeichert. Das folgende Beispiel zeigt, wie eine lokale Verbindung in einer dieser Dateien aussehen könnte:

<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>

Dadurch kann Ihre Anwendung programmgesteuert über WidgetsContext auf die Verbindungszeichenfolge WidgetsContext . Obwohl sowohl Integrated Security=SSPI als auch Integrated Security=True die gleiche Funktion erfüllen, Integrated Security=SSPI wird bevorzugt, da es sowohl mit dem SQLClient- als auch dem OleDB-Provider funktioniert, wobei Integrated Security=true eine Ausnahme auslöst, wenn er mit dem OleDb-Provider verwendet wird.

Verschiedene Anschlüsse für verschiedene Anbieter

Jeder Datenanbieter (SQL Server, MySQL, Azure usw.) verfügt über eine eigene Syntax für die Verbindungszeichenfolgen und stellt verschiedene verfügbare Eigenschaften zur Verfügung. ConnectionStrings.com ist eine unglaublich nützliche Ressource, wenn Sie sich nicht sicher sind, wie Ihre aussehen soll.