C# Language
Dostęp do baz danych

Połączenia ADO.NET

Połączenia ADO.NET są jednym z najprostszych sposobów łączenia się z bazą danych z aplikacji C #. Opierają się na użyciu dostawcy i ciągu połączenia, który wskazuje bazę danych do wykonywania zapytań.

Wspólne klasy dostawców danych

Wiele z poniższych to klasy, które są często używane do tworzenia zapytań do baz danych i powiązanych z nimi przestrzeni nazw:

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

Wszystkie te są powszechnie używane do uzyskiwania dostępu do danych za pośrednictwem C # i będą często spotykane podczas tworzenia aplikacji zorientowanych na dane. Można oczekiwać, że wiele innych niewymienionych klas, które implementują te same FooConnection , FooCommand , FooDataReader będą zachowywać się w ten sam sposób.

Wspólny wzorzec dostępu dla połączeń ADO.NET

Typowy wzorzec, którego można użyć podczas uzyskiwania dostępu do danych za pośrednictwem połączenia ADO.NET, może wyglądać następująco:

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

Lub jeśli po prostu przeprowadzasz prostą aktualizację i nie potrzebujesz czytnika, zastosowanie miałaby ta sama podstawowa koncepcja:

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

Możesz nawet zaprogramować zestaw wspólnych interfejsów i nie musisz się martwić o klasy specyficzne dla dostawcy. Podstawowe interfejsy dostarczane przez ADO.NET to:

• IDbConnection - do zarządzania połączeniami z bazą danych
• IDbCommand - do uruchamiania poleceń SQL
• IDbTransaction - do zarządzania transakcjami
• IDataReader - do odczytu danych zwracanych przez polecenie
• IDataAdapter - do kierowania danych do iz zestawów danych

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

Połączenia Entity Framework

Entity Framework udostępnia klasy abstrakcji, które są używane do interakcji z bazowymi bazami danych w postaci klas takich jak DbContext . Te konteksty zazwyczaj składają się z DbSet<T> , które ujawniają dostępne kolekcje, które można przeszukiwać:

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

Sam DbContext obsłuży nawiązywanie połączeń z bazami danych i ogólnie odczyta odpowiednie dane ciągu połączenia z konfiguracji, aby ustalić sposób nawiązywania połączeń:

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

Wykonywanie zapytań Entity Framework

W rzeczywistości wykonanie zapytania Entity Framework może być dość łatwe i po prostu wymaga utworzenia instancji kontekstu, a następnie skorzystania z dostępnych właściwości, aby pobrać lub uzyskać dostęp do danych

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

Entity Framework zapewnia również rozbudowany system śledzenia zmian, którego można użyć do obsługi aktualizacji wpisów w bazie danych, po prostu wywołując SaveChanges() celu wypchnięcia zmian do bazy danych:

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

Ciągi połączeń

Ciąg połączenia to ciąg znaków, który określa informacje o określonym źródle danych i sposobie łączenia się z nim poprzez przechowywanie poświadczeń, lokalizacji i innych informacji.

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

Przechowywanie ciągu połączenia

Zazwyczaj parametry połączenia będą przechowywane w pliku konfiguracyjnym (takim jak app.config lub web.config w aplikacjach ASP.NET). Poniżej przedstawiono przykład, jak może wyglądać połączenie lokalne w jednym z tych plików:

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

Umożliwi to Twojej aplikacji programowy dostęp do ciągu połączenia za pośrednictwem WidgetsContext . Chociaż zarówno Integrated Security=SSPI i Integrated Security=True wykonują tę samą funkcję; Integrated Security=SSPI jest preferowane, ponieważ działa zarówno z dostawcą SQLClient, jak i OleDB, gdzie jako Integrated Security=true zgłasza wyjątek, gdy jest używany z dostawcą OleDb.

Różne połączenia dla różnych dostawców

Każdy dostawca danych (SQL Server, MySQL, Azure itp.) Oferuje własny smak składni dla swoich ciągów połączeń i ujawnia różne dostępne właściwości. ConnectionStrings.com to niezwykle przydatny zasób, jeśli nie masz pewności, jak powinien wyglądać twój.