Szukaj…


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.



Modified text is an extract of the original Stack Overflow Documentation
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow