C# Language
Toegang tot databases

ADO.NET-verbindingen

ADO.NET-verbindingen zijn een van de eenvoudigste manieren om vanuit een C # -applicatie verbinding te maken met een database. Ze vertrouwen op het gebruik van een provider en een verbindingsreeks die naar uw database verwijst om zoekopdrachten uit te voeren.

Algemene gegevensprovidersklassen

Veel van de volgende zijn klassen die vaak worden gebruikt om databases en hun gerelateerde naamruimten te doorzoeken:

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

Al deze worden vaak gebruikt om toegang te krijgen tot gegevens via C # en komen vaak voor in het bouwen van datacentra-applicaties. Van vele andere klassen die niet worden genoemd en die dezelfde FooConnection , FooCommand , FooDataReader klassen FooCommand , kan worden verwacht dat ze zich op dezelfde manier gedragen.

Gemeenschappelijk toegangspatroon voor ADO.NET-verbindingen

Een gemeenschappelijk patroon dat kan worden gebruikt bij het openen van uw gegevens via een ADO.NET-verbinding kan er als volgt uitzien:

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

Of als u alleen een eenvoudige update zou uitvoeren en geen lezer nodig had, zou hetzelfde basisconcept van toepassing zijn:

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

U kunt zelfs programmeren tegen een reeks gemeenschappelijke interfaces en u geen zorgen te maken over de specifieke klassen van de provider. De kerninterfaces van ADO.NET zijn:

• IDbConnection - voor het beheren van databaseverbindingen
• IDbCommand - voor het uitvoeren van SQL-opdrachten
• IDbTransaction - voor het beheren van transacties
• IDataReader - voor het lezen van gegevens die worden geretourneerd door een opdracht
• IDataAdapter - voor het kanaliseren van gegevens van en naar gegevenssets

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

Entity Framework legt abstractieklassen bloot die worden gebruikt voor interactie met onderliggende databases in de vorm van klassen zoals DbContext . Deze contexten bestaan meestal uit DbSet<T> eigenschappen die de beschikbare collecties blootleggen die kunnen worden opgevraagd:

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

De DbContext zelf zorgt voor het maken van de verbindingen met de databases en leest over het algemeen de juiste verbindingsreeksgegevens uit een configuratie om te bepalen hoe de verbindingen tot stand moeten worden gebracht:

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

Entiteitskaderquery's uitvoeren

Het daadwerkelijk uitvoeren van een Entity Framework-query kan vrij eenvoudig zijn en vereist eenvoudig dat u een instantie van de context maakt en vervolgens de beschikbare eigenschappen erop gebruikt om uw gegevens op te halen of te openen

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

Entity Framework biedt ook een uitgebreid systeem voor het bijhouden van wijzigingen dat kan worden gebruikt voor het bijwerken van vermeldingen in uw database door eenvoudig de methode SaveChanges() aan te roepen om wijzigingen in de database door te voeren:

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

Verbindingsreeksen

Een verbindingsreeks is een reeks die informatie opgeeft over een bepaalde gegevensbron en hoe u hiermee verbinding kunt maken door referenties, locaties en andere informatie op te slaan.

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

Uw verbindingsreeks opslaan

Doorgaans wordt een verbindingsreeks opgeslagen in een configuratiebestand (zoals een app.config of web.config in ASP.NET-toepassingen). Het volgende is een voorbeeld van hoe een lokale verbinding eruit zou kunnen zien in een van deze bestanden:

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

Hiermee krijgt uw toepassing via WidgetsContext programmatisch toegang tot de verbindingsreeks. Hoewel zowel Integrated Security=SSPI als Integrated Security=True dezelfde functie vervullen; Integrated Security=SSPI heeft de voorkeur omdat werkt met zowel SQLClient & OleDB-provider, terwijl Integrated Security=true een uitzondering veroorzaakt bij gebruik met de OleDb-provider.

Verschillende verbindingen voor verschillende providers

Elke gegevensprovider (SQL Server, MySQL, Azure, etc.) hebben allemaal hun eigen syntaxis voor hun verbindingsreeksen en stellen verschillende beschikbare eigenschappen bloot. ConnectionStrings.com is een ongelooflijk nuttige bron als u niet zeker weet hoe de uwe eruit zou moeten zien.