Zugriff auf Datenbanken

Zugriff auf Datenbanken

# Verbindungszeichenfolgen

Eine Verbindungszeichenfolge ist eine Zeichenfolge, die Informationen über eine bestimmte Datenquelle angibt und wie man sich mit ihr verbindet, indem Anmeldeinformationen, Standorte und andere Informationen gespeichert werden.

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

# Speichern Ihrer Verbindungszeichenfolge

Normalerweise wird eine Verbindungszeichenfolge in einer Konfigurationsdatei gespeichert (z. B. ein app.config oder web.config innerhalb von ASP.NET-Anwendungen). Das Folgende ist ein Beispiel dafür, 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 zugreifen . Obwohl beide Integrated Security=SSPI und Integrated Security=True die gleiche Funktion ausführen;Integrated Security=SSPI wird bevorzugt, da es sowohl mit dem SQLClient- als auch mit dem OleDB-Anbieter funktioniert, wobei Integrated Security=true löst eine Ausnahme aus, wenn es mit dem OleDb-Anbieter verwendet wird.

# Unterschiedliche Verbindungen für verschiedene Anbieter

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

# Entity Framework-Verbindungen

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

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

Die DbContext selbst kümmert sich um die Herstellung der Verbindungen mit den Datenbanken und liest im Allgemeinen die entsprechenden Connection-String-Daten 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; } 
}

# Entity Framework-Abfragen ausführen

Die tatsächliche Ausführung einer Entity Framework-Abfrage kann recht einfach sein und erfordert lediglich, dass Sie eine Instanz des Kontexts erstellen und dann die verfügbaren Eigenschaften verwenden, um Ihre Daten abzurufen oder darauf zuzugreifen

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

Entity Framework bietet auch ein umfangreiches Änderungsnachverfolgungssystem, mit dem Sie Einträge in Ihrer Datenbank aktualisieren können, indem Sie einfach SaveChanges() aufrufen Methode um Änderungen in die Datenbank zu pushen :

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

# ADO.NET-Verbindungen

ADO.NET-Verbindungen sind eine der einfachsten Möglichkeiten, um von einer C#-Anwendung aus eine Verbindung mit einer Datenbank herzustellen. Sie verlassen sich auf die Verwendung eines Anbieters und einer Verbindungszeichenfolge, die auf Ihre Datenbank verweist, um Abfragen durchzuführen.

# Gemeinsame Datenanbieterklassen

Viele der folgenden sind Klassen, die häufig verwendet werden, um Datenbanken und ihre zugehörigen Namespaces abzufragen:

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

All diese werden häufig verwendet, um über C# auf Daten zuzugreifen, und werden häufig beim Erstellen datenzentrierter Anwendungen angetroffen. Viele andere Klassen, die nicht erwähnt werden, implementieren denselben FooConnection ,FooCommand ,FooDataReader von Klassen erwartet werden kann, dass sie sich genauso verhalten.

# Gemeinsames 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 Reader benötigen, würde das gleiche 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 gegen eine Reihe gängiger 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 Kanalisieren 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()) {
                ...
            }
        }
    }
}


No