C# Language
Åtkomst till databaser

ADO.NET-anslutningar

ADO.NET-anslutningar är ett av de enklaste sätten att ansluta till en databas från en C # -applikation. De litar på användningen av en leverantör och en anslutningssträng som pekar på din databas för att utföra frågor mot.

Gemensamma dataleverantörsklasser

Många av följande är klasser som vanligtvis används för att fråga databaser och deras relaterade namnutrymmen:

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

Alla dessa används vanligtvis för att få åtkomst till data via C # och kommer ofta att stöta på i byggande av datacentriska applikationer. Många andra klasser som inte nämns som implementerar samma FooConnection , FooCommand , FooDataReader klasser kan förväntas bete sig på samma sätt.

Gemensamt åtkomstmönster för ADO.NET-anslutningar

Ett vanligt mönster som kan användas när du kommer åt dina data via en ADO.NET-anslutning kan se ut enligt följande:

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

Eller om du bara utförde en enkel uppdatering och inte krävde en läsare, skulle samma grundkoncept gälla:

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

Du kan till och med programmera mot en uppsättning gemensamma gränssnitt och inte behöva oroa dig för leverantörens specifika klasser. Kärngränssnitten som tillhandahålls av ADO.NET är:

• IDbConnection - för att hantera databasanslutningar
• IDbCommand - för att köra SQL-kommandon
• IDbTransaction - för att hantera transaktioner
• IDataReader - för att läsa data som returneras av ett kommando
• IDataAdapter - för att kanalisera data till och från datasätt

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()) {
                ...
            }
        }
    }
}

Anslutningar till enhetens ramverk

Entity Framework exponerar abstraktionsklasser som används för att interagera med underliggande databaser i form av klasser som DbContext . Dessa sammanhang består vanligtvis av DbSet<T> -egenskaper som visar de tillgängliga samlingarna som kan frågas:

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

DbContext själv kommer att hantera DbContext av anslutningar med databaserna och kommer i allmänhet att läsa lämpliga anslutningssträngdata från en konfiguration för att bestämma hur man upprättar anslutningarna:

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

Utföra enhetsramfrågor

Att faktiskt köra en Entity Framework-fråga kan vara ganska enkelt och kräver helt enkelt att du skapar en instans av sammanhanget och sedan använder de tillgängliga egenskaperna på den för att dra eller få åtkomst till dina data

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

Entity Framework tillhandahåller också ett omfattande system för ändringsspårning som kan användas för att hantera uppdatering av poster i din databas genom att helt enkelt ringa SaveChanges() för att driva ändringar i databasen:

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

Anslutningssträngar

En anslutningssträng är en sträng som anger information om en viss datakälla och hur man kan ansluta till den genom att lagra referenser, platser och annan information.

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

Lagra din anslutningssträng

Vanligtvis lagras en anslutningssträng i en konfigurationsfil (t.ex. en app.config eller web.config ASP.NET-applikationer). Följande är ett exempel på hur en lokal anslutning kan se ut i en av dessa filer:

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

Detta gör att din applikation kan komma åt anslutningssträngen programmatiskt via WidgetsContext . Även om både Integrated Security=SSPI och Integrated Security=True utför samma funktion; Integrated Security=SSPI är att föredra eftersom det fungerar med både SQLClient- och OleDB-leverantören där Integrated Security=true kastar ett undantag när det används med OleDb-leverantören.

Olika anslutningar för olika leverantörer

Varje dataleverantör (SQL Server, MySQL, Azure, etc.) har alla sin egen smak av syntax för sina anslutningssträngar och exponerar olika tillgängliga egenskaper. ConnectionStrings.com är en oerhört användbar resurs om du är osäker på hur din ska se ut.