Wprowadzenie do przestrzeni nazw Microsoft.Data.SqlClient

pobierz ADO.NET

Przestrzeń nazw Microsoft.Data.SqlClient jest zasadniczo nową wersją przestrzeni nazw System.Data.SqlClient. Microsoft.Data.SqlClient zazwyczaj zachowuje ten sam interfejs API i kompatybilność wsteczną z System.Data.SqlClient. Aby przeprowadzić migrację z elementu System.Data.SqlClient do obiektu Microsoft.Data.SqlClient, w przypadku większości aplikacji jest to proste. Dodaj zależność NuGet od elementu Microsoft.Data.SqlClient i zaktualizuj odwołania oraz instrukcje using do elementu Microsoft.Data.SqlClient.

Istnieje kilka różnic w mniej używanych interfejsach API w porównaniu z System.Data.SqlClient, które mogą mieć wpływ na niektóre aplikacje. W przypadku tych różnic zapoznaj się z przydatną ściągawką do portowania.

Dokumentacja interfejsu API

Szczegóły dotyczące interfejsu API Microsoft.Data.SqlClient można znaleźć w przeglądarce API .NET.

Informacje o wersji programu Microsoft.Data.SqlClient 6.0

Zmiany powodujące niezgodność w wersji 6.0

• Porzucona obsługa platformy .NET Standard. #2386
• Porzucona obsługa platformy .NET 6 #2927
• Usunięte referencje UWP (UAP). #2483
• Porzucona obsługa debugowania po stronie klienta SQL 2000 dla programu .NET Framework #2981, #2940

Nowe funkcje w wersji 6.0

• Dodano obsługę typu danych JSON #2916, #2892, #2891, #2880, #2882, #2829, #2830
• Dodano obsługę platformy .NET 9 #2946
• Dodano typ Microsoft.Data.SqlClient.Diagnostics.SqlClientDiagnostic na platformie .NET. #2226
• Dodano obsługę DateOnly i TimeOnly do DataTable jako parametru strukturalnego. #2258
• Dodano obsługę SqlConnectionOverrides w API OpenAsync()#2433
• Dodano lokalizację w języku czeskim, polskim i tureckim #2987
• Dodano obiekt TokenCredential w celu korzystania z buforowania tokenów w ActiveDirectoryAuthenticationProvider. #2380
• Dodano plik readme do pakietu NuGet #2826
• Włączono inspekcję pakietów NuGet ze źródła inspekcji NuGet.org #3024
• Dodano brakujący przykładowy kod SqlCommand_BeginExecuteReader #3009
• Dodano ślad zakresu dla GenerateSspiClientContext. #2497, #2725

Obsługa typów danych JSON

Obsługa typów danych JSON jest teraz dostępna w programie Microsoft.Data.SqlClient w wersji 6.0. W tej wersji wprowadzono typ SqlJson dostępny jako rozszerzenie do System.Data.SqlDbTypes:

using System;
using System.Data.SqlTypes;
using System.Text.Json;

namespace Microsoft.Data.SqlTypes
{
    /// <summary>
    /// Represents the Json data type in SQL Server.
    /// </summary>
    public class SqlJson : INullable
    {
        /// <summary>
        /// Parameterless constructor. Initializes a new instance of the SqlJson class which 
        /// represents a null JSON value.
        /// </summary>
        public SqlJson() { }

        /// <summary>
        /// Takes a <see cref="string"/> as input and initializes a new instance of the SqlJson class.
        /// </summary>
        /// <param name="jsonString"></param>
        public SqlJson(string jsonString) { }

        /// <summary>
        /// Takes a <see cref="JsonDocument"/> as input and initializes a new instance of the SqlJson class.
        /// </summary>
        /// <param name="jsonDoc"></param>
        public SqlJson(JsonDocument jsonDoc) { }

        /// <inheritdoc/>
        public bool IsNull => throw null;

        /// <summary>
        /// Represents a null instance of the <see cref="SqlJson"/> type.
        /// </summary>
        public static SqlJson Null { get { throw null; } }

        /// <summary>
        /// Gets the string representation of the JSON content of this <see cref="SqlJson" /> instance.
        /// </summary>
        public string Value { get ; }
    }
}

Typ danych JSON obsługuje operacje odczytu, zapisu, przesyłania strumieniowego i kopiowania zbiorczego.

Wprowadzenie SqlClientDiagnostics

Nowe typy są dostępne w przestrzeni nazw Microsoft.Data.SqlClient.Diagnostics, które zapewniają silnie typizowaną kolekcję par klucz-wartość. Te typy mogą być przechwytywane przez używanie aplikacji do zbierania zdarzeń diagnostycznych emitowanych przez sterownik. W tej wersji wprowadzono następujące typy:

• SqlClientCommandBefore
• SqlClientCommandAfter
• SqlClientCommandError
• SqlClientConnectionOpenBefore
• SqlClientConnectionOpenAfter
• SqlClientConnectionOpenError
• SqlClientConnectionCloseBefore
• SqlClientConnectionCloseAfter
• SqlClientConnectionCloseError
• SqlClientTransactionCommitBefore
• SqlClientTransactionCommitAfter
• SqlClientTransactionCommitError
• SqlClientTransactionRollbackBefore
• SqlClientTransactionRollbackAfter
• SqlClientTransactionRollbackError

Dodano obsługę przesłonięć połączeń w interfejsie API OpenAsync()

Domyślne zachowanie SqlConnection.OpenAsync() można zastąpić, aby wyłączyć dziesięcio sekundowe opóźnienie i automatyczne ponawianie prób połączenia wyzwalane przez błędy przejściowe.

using(SqlConnection sqlConnection = new SqlConnection("Data Source=(local);Integrated Security=true;Initial Catalog=AdventureWorks;"))
{
    await sqlConnection.OpenAsync(SqlConnectionOverrides.OpenWithoutRetry, cancellationToken);
}

Obsługa platformy docelowej w wersji 6.0

• .NET Framework 4.6.2+ (Windows x86, Windows x64)
• .NET 8.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 6.0 Informacje o wersji.

Informacje o wersji programu Microsoft.Data.SqlClient 5.2

Nowe funkcje w wersji 5.2

• Dodano obsługę SqlDiagnosticListener w .NET Standard. #1931
• Dodano nową właściwość RowsCopied64 do SqlBulkCopy. #2004Przeczytaj więcej
• Dodano nowy interfejs API AccessTokenCallBack do SqlConnection. #1260Przeczytaj więcej
• Dodano obsługę opcji rejestru SuperSocketNetLib dla funkcji Szyfruj na platformie .NET w systemie Windows. #2047
• Dodano obsługę SqlBatch na platformie .NET 6+ #1825, #2223Przeczytaj więcej
• Dodano obsługę uwierzytelniania tożsamości obciążenia #2159, #2264
• Dodano obsługę lokalizacji na platformie .NET #2210
• Dodano obsługę gruzińskiego sortowania #2194
• Dodano obsługę systemów Big Endian #2170
• Dodano obsługę platformy .NET 8 #2230
• Dodano konkretną wersję dla głównych zależności .NET: System.Runtime.Caching 8.0.0, System.Configuration.ConfigurationManager 8.0.0 i System.Diagnostics.DiagnosticSource 8.0.0 #2303
• Dodano możliwość generowania symboli debugowania w osobnym pliku pakietu #2137

Dodano nową właściwość RowsCopied64 do narzędzia SqlBulkCopy

Narzędzie SqlBulkCopy ma nową właściwość RowsCopied64, która obsługuje typy wartości long.

Należy pamiętać, że istniejące zachowanie SqlBulkCopy.RowsCopied pozostaje niezmienione. Gdy wartość przekroczy int.MaxValue, RowsCopied może zwrócić liczbę ujemną.

Przykładowe użycie:

    using (SqlConnection srcConn = new SqlConnection(srcConstr))
    using (SqlCommand srcCmd = new SqlCommand("select top 5 * from employees", srcConn))
    {
        srcConn.Open();
        using (DbDataReader reader = srcCmd.ExecuteReader())
        {
            using (SqlBulkCopy bulkcopy = new SqlBulkCopy(dstConn))
            {
                bulkcopy.DestinationTableName = dstTable;
                SqlBulkCopyColumnMappingCollection ColumnMappings = bulkcopy.ColumnMappings;

                ColumnMappings.Add("EmployeeID", "col1");
                ColumnMappings.Add("LastName", "col2");
                ColumnMappings.Add("FirstName", "col3");

                bulkcopy.WriteToServer(reader);
                long rowsCopied = bulkcopy.RowsCopied64;
            }
        }
    }

Dodano nową właściwość AccessTokenCallBack do programu SqlConnection

Program SqlConnection obsługuje uwierzytelnianie TokenCredential przez wprowadzenie nowej właściwości AccessTokenCallBack jako delegata Func<SqlAuthenticationParameters, CancellationToken,Task<SqlAuthenticationToken>> w celu zwrócenia tokenu dostępu uwierzytelniania federacyjnego.

Przykładowe użycie:

using Microsoft.Data.SqlClient;
using Azure.Identity;

const string defaultScopeSuffix = "/.default";
string connectionString = GetConnectionString();
DefaultAzureCredential credential = new();
using SqlConnection connection = new(connectionString);

connection.AccessTokenCallback = async (authParams, cancellationToken) =>
{
    string scope = authParams.Resource.EndsWith(defaultScopeSuffix)
        ? authParams.Resource
        : $"{authParams.Resource}{defaultScopeSuffix}";
    AccessToken token = await credential.GetTokenAsync(
        new TokenRequestContext([scope]),
        cancellationToken);

    return new SqlAuthenticationToken(token.Token, token.ExpiresOn);
}

connection.Open();
Console.WriteLine("ServerVersion: {0}", connection.ServerVersion);
Console.WriteLine("State: {0}", connection.State);

SqlBatch API

Przykładowe użycie:

using Microsoft.Data.SqlClient;

class Program
{
    static void Main()
    {
        string str = "Data Source=(local);Initial Catalog=Northwind;"
        + "Integrated Security=SSPI;Encrypt=False";
        RunBatch(str);
    }

    static void RunBatch(string connString)
    {
        using var connection = new SqlConnection(connString);
        connection.Open();

        var batch = new SqlBatch(connection);

        const int count = 10;
        const string parameterName = "parameter";
        for (int i = 0; i < count; i++)
        {
            var batchCommand = new SqlBatchCommand($"SELECT @{parameterName} as value");
            batchCommand.Parameters.Add(new SqlParameter(parameterName, i));
            batch.BatchCommands.Add(batchCommand);
        }

        // Optionally Prepare
        batch.Prepare();

        var results = new List<int>(count);
        using (SqlDataReader reader = batch.ExecuteReader())
        {
            do
            {
                while (reader.Read())
                {
                    results.Add(reader.GetFieldValue<int>(0));
                }
            } while (reader.NextResult());
        }
        Console.WriteLine(string.Join(", ", results));
    }
}

5.2 Obsługa platformy docelowej

• .NET Framework 4.6.2+ (Windows x86, Windows x64)
• .NET 6.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 5.2 Informacje o wersji.

Zmiany przełomowe w wersji 5.1

• Porzucona obsługa platformy .NET Core 3.1. #1704#1823

Nowe funkcje w wersji 5.1

• Dodano obsługę DateOnly i TimeOnly dla wartości SqlParameter i GetFieldValue. #1813
• Dodano obsługę protokołu TLS 1.3 dla platform .NET Core i SNI Native. #1821
• Dodano ustawienie ServerCertificate dla Encrypt=Mandatory lub Encrypt=Strict. #1822Przeczytaj więcej
• Dodano obsługę systemu Windows Arm64 przy pracy z platformą .NET Framework. #1828

Certyfikat serwera

Wartość domyślna ustawienia połączenia ServerCertificate jest pustym ciągiem znaków. Gdy Encrypt jest ustawiona na Mandatory lub Strict, ServerCertificate można użyć do określenia ścieżki w systemie plików do pliku certyfikatu, który ma być zgodny z certyfikatem TLS/SSL serwera. Określony certyfikat musi dokładnie odpowiadać, aby był prawidłowy. Akceptowane formaty certyfikatów to PEM, DERi CER. Oto przykład użycia:

"Data Source=...;Encrypt=Strict;ServerCertificate=C:\\certificates\\server.cer"

5.1 Obsługa platformy docelowej

• .NET Framework 4.6.2+ (Windows x86, Windows x64)
• .NET 6.0+ (Windows x86, Windows x64, Windows Arm64, Windows Azure Resource Manager, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 5.1 Informacje o wersji.

Informacje o wersji programu Microsoft.Data.SqlClient 5.0

Zmiany powodujące niezgodność w wersji 5.0

• Porzucona obsługa programu .NET Framework 4.6.1 #1574
• Dodano zależność od pakietu Microsoft.SqlServer.Server. Ta nowa zależność może powodować konflikty przestrzeni nazw, jeśli aplikacja odwołuje się do tej przestrzeni nazw i nadal zawiera odwołania do pakietów (bezpośrednie lub pośrednie) do elementu System.Data.SqlClient z platformy .NET Core.
• Usunięto klasy z przestrzeni nazw Microsoft.Data.SqlClient.Server i zastąpiono je obsługiwanymi typami z pakietu Microsoft.SqlServer.Server.#1585. Objęte klasy i wyliczenia to:
  • Microsoft.Data.SqlClient.Server.IBinarySerialize —> Microsoft.SqlServer.Server.IBinarySerialize
  • Microsoft.Data.SqlClient.Server.InvalidUdtException –> Microsoft.SqlServer.Server.InvalidUdtException
  • Microsoft.Data.SqlClient.Server.SqlFacetAttribute —> Microsoft.SqlServer.Server.SqlFacetAttribute
  • Microsoft.Data.SqlClient.Server.SqlFunctionAttribute —> Microsoft.SqlServer.Server.SqlFunctionAttribute
  • Microsoft.Data.SqlClient.Server.SqlMethodAttribute —> Microsoft.SqlServer.Server.SqlMethodAttribute
  • Microsoft.Data.SqlClient.Server.SqlUserDefinedAggregateAttribute —> Microsoft.SqlServer.Server.SqlUserDefinedAggregateAttribute
  • Microsoft.Data.SqlClient.Server.SqlUserDefinedTypeAttribute —> Microsoft.SqlServer.Server.SqlUserDefinedTypeAttribute
  • (wyliczenie) Microsoft.Data.SqlClient.Server.DataAccessKind:> Microsoft.SqlServer.Server.DataAccessKind
  • (wyliczenie) Microsoft.Data.SqlClient.Server.Format —> Microsoft.SqlServer.Server.Format
  • (wyliczenie) Microsoft.Data.SqlClient.Server.SystemDataAccessKind —> Microsoft.SqlServer.Server.SystemDataAccessKind

Nowe funkcje w wersji 5.0

• Dodano obsługę TDS8. Aby użyć usługi TDS 8, użytkownicy powinni określić wartość Encrypt=Strict w parametrach połączenia. #1608Przeczytaj więcej
• Dodano obsługę określania SPN serwera i SPN serwera trybu failover w połączeniu. #1607Przeczytaj więcej
• Dodano obsługę aliasów dla platformy .NET Core w systemie Windows. #1588Przeczytaj więcej
• Dodano moduł SqlDataSourceEnumerator. #1430, Przeczytaj więcej
• Dodano nowy przełącznik AppContext w celu pomijania niezabezpieczonych ostrzeżeń protokołu TLS. #1457, Przeczytaj więcej

Ulepszone zabezpieczenia TDS 8

Aby użyć TDS 8, określ wartość Encrypt=Strict w parametrach połączenia. Tryb ścisły wyłącza element TrustServerCertificate (zawsze traktowany jako fałsz w trybie ścisłym). Element HostNameInCertificate został dodany w celu ułatwienia niektórych scenariuszy trybu ścisłego. TDS 8 inicjuje i kontynuuje całą komunikację serwera w ramach bezpiecznego, zaszyfrowanego połączenia TLS.

Dodano nowe wartości szyfrowania w celu wyjaśnienia zachowania szyfrowania połączeń. Encrypt=Mandatory jest odpowiednikiem Encrypt=True i szyfruje połączenia podczas negocjacji połączenia TDS. Encrypt=Optional jest odpowiednikiem Encrypt=False i szyfruje połączenie tylko wtedy, gdy serwer informuje klienta, że szyfrowanie jest wymagane podczas negocjacji połączenia TDS.

Aby uzyskać więcej informacji na temat szyfrowania połączeń z serwerem, zobacz Szyfrowanie i walidacja certyfikatu.

HostNameInCertificate można określić w parametrach połączenia podczas używania aliasów do nawiązywania połączenia z szyfrowaniem z serwerem, który ma certyfikat serwera o innej nazwie lub alternatywnej nazwie podmiotu niż nazwa używana przez klienta do identyfikacji serwera (aliasy DNS, na przykład). Przykładowe użycie: HostNameInCertificate=MyDnsAliasName

Nazwa SPN serwera

Podczas nawiązywania połączenia w środowisku, które ma unikatową topografię domeny/lasu, mogą istnieć określone wymagania dotyczące nazw SPN dla serwera. Parametry połączenia ServerSPN/Server SPN i FailoverServerSPN/Failover Server SPN mogą być używane do zastępowania automatycznie generowanych nazw SPN serwera używanych podczas zintegrowanego uwierzytelniania w środowisku domenowym.

Obsługa aliasów SQL

Użytkownicy mogą konfigurować aliasy przy użyciu menedżera konfiguracji programu SQL Server. Te aliasy są przechowywane w rejestrze systemu Windows i są już obsługiwane przy kierowaniu na platformę .NET Framework. Ta wersja zapewnia obsługę aliasów podczas celowania w .NET lub .NET Core na Windows.

Obsługa modułu wyliczającego źródła danych SQL

Udostępnia mechanizm wyliczania wszystkich dostępnych wystąpień programu SQL Server w sieci lokalnej.

using Microsoft.Data.Sql;
static void Main()  
  {  
    // Retrieve the enumerator instance and then the data.  
    SqlDataSourceEnumerator instance =  
      SqlDataSourceEnumerator.Instance;  
    System.Data.DataTable table = instance.GetDataSources();  
  
    // Display the contents of the table.  
    DisplayData(table);  
  
    Console.WriteLine("Press any key to continue.");  
    Console.ReadKey();  
  }  
  
  private static void DisplayData(System.Data.DataTable table)  
  {  
    foreach (System.Data.DataRow row in table.Rows)  
    {  
      foreach (System.Data.DataColumn col in table.Columns)  
      {  
        Console.WriteLine("{0} = {1}", col.ColumnName, row[col]);  
      }  
      Console.WriteLine("============================");  
    }  
  }  

Pomijanie niezabezpieczonych ostrzeżeń protokołu TLS

Ostrzeżenie o zabezpieczeniach jest wyświetlane w konsoli programu , jeśli wersja protokołu TLS mniejsza niż 1.2 jest używana do negocjowania z serwerem. To ostrzeżenie może zostać pominięte w połączeniu SQL podczas Encrypt = false przez włączenie następującego przełącznika AppContext podczas uruchamiania aplikacji:

Switch.Microsoft.Data.SqlClient.SuppressInsecureTLSWarning

Obsługa platformy docelowej 5.0

• .NET Framework 4.6.2+ (Windows x86, Windows x64)
• .NET Core 3.1+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Pełne notatki o wydaniu, w tym informacje o zależnościach, są dostępne w repozytorium GitHub: 5.0 Notatki o wydaniu.

Informacje o wersji programu Microsoft.Data.SqlClient 4.1

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 4.1 Informacje o wersji.

Nowe funkcje w wersji 4.1

Wprowadzenie protokołu zaświadczania None

Nowy protokół zaświadczania o nazwie None jest dozwolony w parametrach połączenia. Ten protokół umożliwia użytkownikom odejście od zaświadczania enklawy dla enklaw VBS. Po ustawieniu tego protokołu właściwość adresu URL zaświadczania enklawy jest opcjonalna.

Przykład parametrów połączenia:

//Attestation protocol NONE with no URL
"Data Source = {server}; Initial Catalog = {db}; Column Encryption Setting = Enabled; Attestation Protocol = None;"

4.1 Obsługa platformy docelowej

• .NET Framework 4.6.1+ (Windows x86, Windows x64)
• .NET Core 3.1+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Informacje o wersji programu Microsoft.Data.SqlClient 4.0

Kompletne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: Informacje o wersji 4.0.

Zmiany łamiące zgodność w wersji 4.0

• Zmieniono domyślną właściwość ciągu połączenia Encrypt na true. #1210Przeczytaj więcej
• Sterownik teraz używa SqlException zamiast AggregateException dla trybów uwierzytelniania usługi Active Directory. #1213
• Usunięto przestarzałą właściwość połączenia Asynchronous Processing z programu .NET Framework. #1148
• Usunięto przełącznik bezpieczeństwa Configurable Retry Logic. #1254Przeczytaj więcej
• Porzucona obsługa platformy .NET Core 2.1 #1272
• [.NET Framework] Wyjątek nie jest zgłaszany, jeśli identyfikator użytkownika jest podany w parametrach połączenia podczas korzystania z uwierzytelniania Active Directory Integrated#1359

Nowe funkcje w wersji 4.0

Szyfruj wartość domyślną ustawioną na true

Wartość domyślna ustawienia połączenia Encrypt została zmieniona z false na true. Wraz z rosnącym użyciem baz danych w chmurze i koniecznością zapewnienia bezpieczeństwa tych połączeń, nadszedł czas na zmianę uniemożliwiającą zgodność wsteczną.

Upewnij się, że połączenia kończą się niepowodzeniem, gdy wymagane jest szyfrowanie

W scenariuszach, w których biblioteki szyfrowania klienta były wyłączone lub niedostępne, możliwe było, aby nieszyfrowane połączenia były wykonywane, gdy szyfrowanie zostało ustawione na wartość true lub wymagane szyfrowanie serwera.

Przełącznik kontekstu aplikacji do korzystania z domyślnych protokołów systemowych

Protokół TLS 1.3 nie jest obsługiwany przez sterownik; w związku z tym został on domyślnie usunięty z listy obsługiwanych protokołów. Użytkownicy mogą ponownie wymusić użycie protokołów klienta systemu operacyjnego, włączając przełącznik kontekstu aplikacji:

Switch.Microsoft.Data.SqlClient.UseSystemDefaultSecureProtocols

Włączanie zoptymalizowanego powiązania parametrów

Microsoft.Data.SqlClient wprowadza nowy interfejs API SqlCommand, EnableOptimizedParameterBinding w celu zwiększenia wydajności zapytań z dużą liczbą parametrów. Ta właściwość jest domyślnie wyłączona. Gdy ustawiono wartość true, nazwy parametrów nie są wysyłane do wystąpienia SQL Server, gdy polecenie jest wykonywane.

public class SqlCommand
{
    public bool EnableOptimizedParameterBinding { get; set; }
}

Usuń konfigurowalny przełącznik zabezpieczeń logiki ponawiania prób

Przełącznik kontekstu aplikacji "Switch.Microsoft.Data.SqlClient.EnableRetryLogic" nie jest już wymagany do korzystania z konfigurowalnej funkcji logiki ponawiania prób. Funkcja jest teraz obsługiwana w środowisku produkcyjnym. Domyślne zachowanie funkcji nadal jest zasadą braku ponawiania, którą aplikacje klienckie muszą nadpisać, aby umożliwić ponawianie prób.

Wsparcie udostępnionego wystąpienia SqlLocalDb

SqlLocalDb obsługuje teraz wystąpienia udostępnione podczas korzystania z Managed SNI.

• Możliwe scenariusze:
  • (localdb)\. (nawiązuje połączenie z domyślną instancją SqlLocalDb)
  • (localdb)\<named instance>
  • (localdb)\.\<shared instance name> (*nowo dodana obsługa)

obsługa GetFieldValueAsync<T> i GetFieldValue<T> dla typów XmlReader, TextReaderi Stream

Typy XmlReader, TextReader, Stream są teraz obsługiwane w przypadku używania GetFieldValueAsync<T> i GetFieldValue<T>.

Przykładowe użycie:

using (SqlConnection connection = new SqlConnection(connectionString))
{
    using (SqlCommand command = new SqlCommand(query, connection))
    {
        connection.Open();
        using (SqlDataReader reader = await command.ExecuteReaderAsync())
        {
            if (await reader.ReadAsync())
            {
                using (Stream stream = await reader.GetFieldValueAsync<Stream>(1))
                {
                    // Continue to read from stream
                }
            }
        }
    }
}

Obsługa platformy docelowej 4.0

• .NET Framework 4.6.1+ (Windows x86, Windows x64)
• .NET Core 3.1+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Informacje o wersji programu Microsoft.Data.SqlClient 3.0

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 3.0 Informacje o wersji.

Zmiany powodujące niezgodność w wersji 3.0

• Minimalna obsługiwana wersja programu .NET Framework została zwiększona do wersji 4.6.1. Program .NET Framework w wersji 4.6.0 nie jest już obsługiwany. #899
• User Id właściwość połączenia wymaga teraz Client Id zamiast Object Id dla User-Assigned tożsamości zarządzanej#1010Przeczytaj więcej
• SqlDataReader teraz zwraca wartość DBNull zamiast pustej byte[]. Zachowanie starszej wersji można włączyć, ustawiając przełącznik AppContextSwitch.Microsoft.Data.SqlClient.LegacyRowVersionNullBehavior#998Więcej informacji

Nowe funkcje w wersji 3.0

Konfigurowalna logika ponawiania prób

Ta nowa funkcja wprowadza konfigurowalną obsługę aplikacji klienckich do ponawiania prób w przypadku błędów "przejściowych" lub "powtarzalnych". Konfigurację można wykonać za pomocą plików konfiguracji kodu lub aplikacji, a operacje ponawiania prób można zastosować do otwierania połączenia lub wykonywania polecenia. Ta funkcja jest domyślnie wyłączona i jest obecnie dostępna w wersji zapoznawczej. Aby włączyć tę obsługę, aplikacje klienckie muszą włączyć następujący przełącznik bezpieczeństwa:

AppContext.SetSwitch("Switch.Microsoft.Data.SqlClient.EnableRetryLogic", true);

Po włączeniu przełącznika AppContext platformy .NET można zdefiniować zasady logiki ponawiania dla SqlConnection i SqlCommand niezależnie lub razem przy użyciu różnych opcji dostosowywania.

Nowe publiczne interfejsy API są wprowadzane w SqlConnection i SqlCommand w celu rejestrowania niestandardowej implementacji SqlRetryLogicBaseProvider.

public SqlConnection
{
    public SqlRetryLogicBaseProvider RetryLogicProvider;
}

public SqlCommand
{
    public SqlRetryLogicBaseProvider RetryLogicProvider;
}

Przykłady użycia interfejsu API można znaleźć tutaj:

using Microsoft.Data.SqlClient;

/// Detecting retriable exceptions is a vital part of the retry pattern.
/// Before applying retry logic it is important to investigate exceptions and choose a retry provider that best fits your scenario.
/// First, log your exceptions and find transient faults.
/// The purpose of this sample is to illustrate how to use this feature and the condition might not be realistic.
class RetryLogicSample
{
    private const string DefaultDB = "Northwind";
    private const string CnnStringFormat = "Server=localhost; Initial Catalog={0}; Integrated Security=true; pooling=false;";
    private const string DropDatabaseFormat = "DROP DATABASE {0}";

    // For general use
    private static SqlConnection s_generalConnection = new SqlConnection(string.Format(CnnStringFormat, DefaultDB));

    static void Main(string[] args)
    {
        // 1. Define the retry logic parameters
        var options = new SqlRetryLogicOption()
        {
            NumberOfTries = 5,
            MaxTimeInterval = TimeSpan.FromSeconds(20),
            DeltaTime = TimeSpan.FromSeconds(1)
        };

        // 2. Create a retry provider
        var provider = SqlConfigurableRetryFactory.CreateExponentialRetryProvider(options);

        // define the retrying event to report the execution attempts
        provider.Retrying += (object s, SqlRetryingEventArgs e) =>
            {
                int attempts = e.RetryCount + 1;
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"attempt {attempts} - current delay time:{e.Delay} \n");
                Console.ForegroundColor = ConsoleColor.DarkGray;
                if (e.Exceptions[e.Exceptions.Count - 1] is SqlException ex)
                {
                    Console.WriteLine($"{ex.Number}-{ex.Message}\n");
                }
                else
                {
                    Console.WriteLine($"{e.Exceptions[e.Exceptions.Count - 1].Message}\n");
                }

                // It is not a good practice to do time-consuming tasks inside the retrying event which blocks the running task.
                // Use parallel programming patterns to mitigate it.
                if (e.RetryCount == provider.RetryLogic.NumberOfTries - 1)
                {
                    Console.WriteLine("This is the last chance to execute the command before throwing the exception.");
                    Console.WriteLine("Press Enter when you're ready:");
                    Console.ReadLine();
                    Console.WriteLine("continue ...");
                }
            };

        // Open the general connection.
        s_generalConnection.Open();

        try
        {
            // Assume the database is being created and other services are going to connect to it.
            RetryConnection(provider);
        }
        catch
        {
            // exception is thrown if connecting to the database isn't successful.
            throw;
        }
    }

    private static void ExecuteCommand(SqlConnection cn, string command)
    {
        using var cmd = cn.CreateCommand();
        cmd.CommandText = command;
        cmd.ExecuteNonQuery();
    }

    private static void RetryConnection(SqlRetryLogicBaseProvider provider)
    {
        // Change this if you already have a database with the same name in your database.
        string dbName = "Invalid_DB_Open";

        // Create a connection to an invalid database.
        using var cnn = new SqlConnection(string.Format(CnnStringFormat, dbName));
        // 3. Assign the `provider` to the connection
        cnn.RetryLogicProvider = provider;
        Console.WriteLine($"Connecting to the [{dbName}] ...");
        // Manually execute the following command in SSMS to create the invalid database while the SqlConnection is attempting to connect to it.
        // >> CREATE DATABASE Invalid_DB_Open;
        Console.WriteLine($"Manually, run the 'CREATE DATABASE {dbName};' in the SQL Server before exceeding the {provider.RetryLogic.NumberOfTries} attempts.");
        // the connection tries to connect to the database 5 times
        Console.WriteLine("The first attempt, before getting into the retry logic.");
        cnn.Open();
        Console.WriteLine($"Connected to the [{dbName}] successfully.");

        cnn.Close();

        // Drop it after test
        ExecuteCommand(s_generalConnection, string.Format(DropDatabaseFormat, dbName));
        Console.WriteLine($"The [{dbName}] is removed.");
    }
}

/// Detecting retriable exceptions is a vital part of the retry pattern.
/// Before applying retry logic it is important to investigate exceptions and choose a retry provider that best fits your scenario.
/// First, log your exceptions and find transient faults.
/// The purpose of this sample is to illustrate how to use this feature and the condition might not be realistic.

    private const string DefaultDB = "Northwind";
    private const string CnnStringFormat = "Server=localhost; Initial Catalog={0}; Integrated Security=true; pooling=false;";
    private const string DropDatabaseFormat = "DROP DATABASE {0}";
    private const string CreateDatabaseFormat = "CREATE DATABASE {0}";

    // For general use
    private static SqlConnection s_generalConnection = new SqlConnection(string.Format(CnnStringFormat, DefaultDB));

    static void Main(string[] args)
    {
        // 1. Define the retry logic parameters
        var options = new SqlRetryLogicOption()
        {
            NumberOfTries = 5,
            MaxTimeInterval = TimeSpan.FromSeconds(20),
            DeltaTime = TimeSpan.FromSeconds(1),
            AuthorizedSqlCondition = null,
            // error number 3702 : Cannot drop database "xxx" because it is currently in use.
            TransientErrors = new int[] {3702}
        };

        // 2. Create a retry provider
        var provider = SqlConfigurableRetryFactory.CreateExponentialRetryProvider(options);

        // define the retrying event to report execution attempts
        provider.Retrying += (object s, SqlRetryingEventArgs e) =>
            {
                int attempts = e.RetryCount + 1;
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine($"attempt {attempts} - current delay time:{e.Delay} \n");
                Console.ForegroundColor = ConsoleColor.DarkGray;
                if (e.Exceptions[e.Exceptions.Count - 1] is SqlException ex)
                {
                    Console.WriteLine($"{ex.Number}-{ex.Message}\n");
                }
                else
                {
                    Console.WriteLine($"{e.Exceptions[e.Exceptions.Count - 1].Message}\n");
                }

                // It is not good practice to do time-consuming tasks inside the retrying event which blocks the running task.
                // Use parallel programming patterns to mitigate it.
                if (e.RetryCount == provider.RetryLogic.NumberOfTries - 1)
                {
                    Console.WriteLine("This is the last chance to execute the command before throwing the exception.");
                    Console.WriteLine("Press Enter when you're ready:");
                    Console.ReadLine();
                    Console.WriteLine("continue ...");
                }
            };

        // Open a general connection.
        s_generalConnection.Open();

        try
        {
            // Assume the database is creating and other services are going to connect to it.
            RetryCommand(provider);
        }
        catch
        {
            s_generalConnection.Close();
            // exception is thrown if connecting to the database isn't successful.
            throw;
        }
        s_generalConnection.Close();
    }

    private static void ExecuteCommand(SqlConnection cn, string command)
    {
        using var cmd = cn.CreateCommand();
        cmd.CommandText = command;
        cmd.ExecuteNonQuery();
    }

    private static void FindActiveSessions(SqlConnection cnn, string dbName)
    {
        using var cmd = cnn.CreateCommand();
        cmd.CommandText = "DECLARE @query NVARCHAR(max) = '';" + Environment.NewLine +
            $"SELECT @query = @query + 'KILL ' + CAST(spid as varchar(50)) + ';' FROM sys.sysprocesses WHERE dbid = DB_ID('{dbName}')" + Environment.NewLine +
            "SELECT @query AS Active_sessions;";
        var reader = cmd.ExecuteReader();
        if (reader.Read())
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Write($">> Execute the '{reader.GetString(0)}' command in SQL Server to unblock the running task.");
            Console.ResetColor();
        }
        reader.Close();
    }

var RetryLogicOption = new SqlRetryLogicOption()
{
    NumberOfTries = 5,
    // Declare the error number 102 as a transient error to apply the retry logic when it occurs.
    TransientErrors = new int[] { 102 },
    // When a SqlCommand executes out of a transaction, 
    // the retry logic will apply if it contains a 'select' keyword.
    AuthorizedSqlCondition = x => string.IsNullOrEmpty(x)
            || Regex.IsMatch(x, @"\b(SELECT)\b", RegexOptions.IgnoreCase),
    DeltaTime = TimeSpan.FromSeconds(1),
    MaxTimeInterval = TimeSpan.FromSeconds(60),
    MinTimeInterval = TimeSpan.FromSeconds(3)
};

Wprowadzono również nowe sekcje konfiguracji w celu przeprowadzenia tej samej rejestracji z plików konfiguracji bez konieczności modyfikowania istniejącego kodu:

<section name="SqlConfigurableRetryLogicConnection"
            type="Microsoft.Data.SqlClient.SqlConfigurableRetryConnectionSection, Microsoft.Data.SqlClient"/>

<section name="SqlConfigurableRetryLogicCommand"
            type="Microsoft.Data.SqlClient.SqlConfigurableRetryCommandSection, Microsoft.Data.SqlClient"/>

Oto prosty przykład użycia nowych sekcji konfiguracji w plikach konfiguracji:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="SqlConfigurableRetryLogicConnection"
             type="Microsoft.Data.SqlClient.SqlConfigurableRetryConnectionSection, Microsoft.Data.SqlClient"/>
    <section name="SqlConfigurableRetryLogicCommand"
             type="Microsoft.Data.SqlClient.SqlConfigurableRetryCommandSection, Microsoft.Data.SqlClient"/>

    <section name="AppContextSwitchOverrides"
             type="Microsoft.Data.SqlClient.AppContextSwitchOverridesSection, Microsoft.Data.SqlClient"/>
  </configSections>

  <!--Enable safety switch in .NET Core-->
  <AppContextSwitchOverrides value="Switch.Microsoft.Data.SqlClient.EnableRetryLogic=true"/>

  <!--Retry method for SqlConnection-->
  <SqlConfigurableRetryLogicConnection retryMethod ="CreateFixedRetryProvider" numberOfTries ="3" deltaTime ="00:00:10" maxTime ="00:00:30"
                                    transientErrors="40615" />

  <!--Retry method for SqlCommand containing SELECT queries-->
  <SqlConfigurableRetryLogicCommand retryMethod ="CreateIncrementalRetryProvider" numberOfTries ="5" deltaTime ="00:00:10" maxTime ="00:01:10"
                                    authorizedSqlCondition="\b(SELECT)\b" transientErrors="102, 4060, 0"/>
</configuration>

Alternatywnie aplikacje mogą implementować własnego dostawcę klasy bazowej SqlRetryLogicBaseProvider i zarejestrować go w SqlConnection/SqlCommand.

Liczniki zdarzeń

Następujące liczniki są teraz dostępne dla aplikacji przeznaczonych dla platform .NET Core 3.1+ i .NET Standard 2.1+:

Nazwa	Nazwa wyświetlana	Opis
aktywne połączenia twarde	Rzeczywiste aktywne połączenia obecnie wykonywane z serwerami	Liczba połączeń obecnie otwartych dla serwerów baz danych.
trwałe połączenie	Rzeczywista szybkość połączenia z serwerami	Liczba połączeń na sekundę otwieranych na serwery bazy danych.
twarde odłączania	Rzeczywista szybkość rozłączania z serwerami	Liczba rozłączeń na sekundę do serwerów bazy danych.
aktywne częściowe połączenia	Aktywne połączenia pobrane z puli połączeń	Liczba aktywnie otwartych połączeń konsumowanych z puli połączeń.
delikatnie łączy	Częstotliwość połączeń pobranych z puli połączeń	Liczba połączeń na sekundę zużywanych z puli połączeń.
delikatne rozłączenia	Szybkość połączeń zwróconych do puli połączeń	Liczba połączeń na sekundę zwracanych do puli połączeń.
liczba niescalanych połączeń	Liczba połączeń, które nie korzystają z buforowania połączeń	Liczba aktywnych połączeń, które nie są w puli.
liczba połączeń w puli	Liczba połączeń zarządzanych przez pulę połączeń	Liczba aktywnych połączeń zarządzała infrastrukturą puli połączeń.
liczba grup aktywnych połączeń puli	Liczba aktywnych unikatowych parametrów połączenia	Liczba aktywnych, unikalnych grup puli połączeń. Ten licznik jest oparty na liczbie unikatowych parametrów połączenia znalezionych w domenie aplikacji.
liczba nieaktywnych grup puli połączeń	Liczba unikatowych parametrów połączenia oczekujących na przycinanie	Liczba unikatowych grup puli połączeń oznaczonych do przycinania. Ten licznik jest oparty na liczbie unikatowych parametrów połączenia znalezionych w domenie aplikacji.
liczba aktywnych pul połączeń	Liczba aktywnych pul połączeń	Łączna liczba pul połączeń.
liczba nieaktywnych pul połączeń	Liczba nieaktywnych pul połączeń	Liczba nieaktywnych pul połączeń bez ostatniej aktywności, czekających na likwidację.
liczba aktywnych połączeń	Liczba aktywnych połączeń	Liczba aktualnie używanych aktywnych połączeń.
liczba bezpłatnych połączeń	Liczba gotowych połączeń w puli połączeń	Liczba otwartych połączeń dostępnych do użycia w pulach połączeń.
liczba połączeń stasis	Liczba połączeń oczekujących obecnie na gotowość	Liczba połączeń oczekujących obecnie na ukończenie akcji i niedostępnych do użycia przez aplikację.
liczba odzyskanych połączeń	Liczba odzyskanych połączeń z GC	Liczba połączeń odzyskanych dzięki mechanizmowi odzyskiwania pamięci, w których Close lub Dispose nie zostało wywołane przez aplikację. Uwaga Nie zamykaj jawnie ani nie usuwaj połączeń, co szkodzi wydajności.

Te liczniki mogą być używane z globalnymi narzędziami wiersza polecenia (CLI) platformy .NET Core: dotnet-counters i dotnet-trace w systemach Windows lub Linux oraz PerfView w systemie Windows z Microsoft.Data.SqlClient.EventSource jako nazwą dostawcy. Aby uzyskać więcej informacji, zobacz Pobieranie wartości licznika zdarzeń.

dotnet-counters monitor Microsoft.Data.SqlClient.EventSource -p
PerfView /onlyProviders=*Microsoft.Data.SqlClient.EventSource:EventCounterIntervalSec=1 collect

Wprowadzenie do zależności Azure Identity

Microsoft.Data.SqlClient teraz zależy od biblioteki Azure.Identity do pozyskiwania tokenów dla trybów uwierzytelniania "Zarządzana tożsamość usługi Active Directory (MSI)" i "Jednostka usługi Active Directory". Ta zmiana wprowadza następujące zmiany w obszarze powierzchni publicznej:

• zmiana powodująca niezgodność
  Właściwość połączenia "Identyfikator użytkownika" wymaga teraz wartości "Identyfikator klienta" zamiast "Identyfikator obiektu" dla "User-Assigned tożsamości zarządzanej".
• publicznego interfejsu API
  Nowa właściwość publiczna tylko do odczytu: SqlAuthenticationParameters.ConnectionTimeout
• zależności
  Azure.Identity, wersja 1.3.0

Ulepszenia śledzenia zdarzeń w SNI.dll

Microsoft.Data.SqlClient.SNI (zależność .NET Framework) i wersje Microsoft.Data.SqlClient.SNI.runtime (zależność .NET Core/Standard) zostały zaktualizowane do v3.0.0-preview1.21104.2. Śledzenie zdarzeń w SNI.dll nie jest już włączone za pośrednictwem aplikacji klienckiej. Abonowanie sesji u dostawcy Microsoft.Data.SqlClient.EventSource za pomocą takich narzędzi, jak xperf lub perfview, jest wystarczające. Aby uzyskać więcej informacji, zobacz obsługę śledzenia zdarzeń w Natywnym SNI.

Włączanie obsługi wartości null w wersji wiersza

SqlDataReader zwraca wartość DBNull zamiast pustej byte[]. Aby włączyć starsze zachowanie, należy włączyć następujący przełącznik AppContext podczas uruchamiania aplikacji: "Switch.Microsoft.Data.SqlClient.LegacyRowVersionNullBehavior"

Obsługa domyślnego uwierzytelniania Microsoft Entra

Notatka

Chociaż identyfikator Entra firmy Microsoft to nowa nazwa usługi Azure Active Directory (Azure AD), aby zapobiec zakłócaniu działania istniejących środowisk, usługa Azure AD nadal pozostaje w niektórych zakodowanych na stałe elementach, takich jak pola interfejsu użytkownika, dostawcy połączeń, kody błędów i polecenia cmdlet. W tym artykule dwie nazwy są wymienne.

To żądanie scalania wprowadza nową metodę uwierzytelniania SQL, domyślne usługi Active Directory. Ten tryb uwierzytelniania rozszerza możliwości uwierzytelniania użytkowników za pomocą Microsoft Entra ID, oferując rozwiązania logowania do środowiska klienta, Visual Studio Code, Visual Studio, interfejsu wiersza poleceń Azure CLI itp.

W tym trybie uwierzytelniania sterownik uzyskuje token, przekazując element "DefaultAzureCredential" z biblioteki tożsamości platformy Azure w celu uzyskania tokenu dostępu. Ten tryb próbuje użyć tych typów poświadczeń w celu uzyskania tokenu dostępu w następującej kolejności:

• EnvironmentCredential
  • Włącza uwierzytelnianie za pomocą Microsoft Entra ID, używając klienta i tajnego klucza lub nazwy użytkownika i hasła, które są skonfigurowane w następujących zmiennych środowiskowych: AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_CLIENT_CERTIFICATE_PATH, AZURE_USERNAME, AZURE_PASSWORD (więcej szczegółów)
• ManagedIdentityCredential
  • Podejmuje próbę uwierzytelniania przy użyciu Microsoft Entra ID, korzystając z zarządzanej tożsamości przypisanej do środowiska wdrażania. "Identyfikator klienta" tożsamości zarządzanej przypisanej przez użytkownika jest odczytywany z właściwości połączenia "Identyfikator użytkownika" .
• SharedTokenCacheCredential
  • Uwierzytelnianie odbywa się przy użyciu tokenów w lokalnej pamięci podręcznej udostępnionej między aplikacjami firmy Microsoft.
• VisualStudioCredential
  • Włącza uwierzytelnianie przy użyciu identyfikatora Entra firmy Microsoft przy użyciu danych z programu Visual Studio
• VisualStudioCodeCredential
  • Włącza uwierzytelnianie za pomocą identyfikatora Entra firmy Microsoft przy użyciu danych z programu Visual Studio Code.
• AzureCliCredential
  • Umożliwia uwierzytelnianie za pomocą identyfikatora Entra firmy Microsoft przy użyciu interfejsu wiersza polecenia platformy Azure w celu uzyskania tokenu dostępu.

InteractiveBrowserCredential jest wyłączony w implementacji sterownika "Active Directory Default", a "Active Directory Interactive" jest jedyną opcją dostępną do uzyskania tokenu przy użyciu uwierzytelniania wieloskładnikowego/interaktywnego.

Dalsze opcje dostosowywania nie są obecnie dostępne.

Ulepszenia rejestracji niestandardowych dostawców głównego magazynu kluczy

Microsoft.Data.SqlClient oferuje teraz większą kontrolę nad tym, gdzie dostawcy magazynu kluczy głównych są dostępni w aplikacji, aby lepiej wspierać aplikacje wielodostępne i ich wykorzystanie szyfrowania/odszyfrowywania kolumn. Wprowadzono następujące interfejsy API umożliwiające rejestrację niestandardowych dostawców magazynu kluczy głównych w wystąpieniach SqlConnection i SqlCommand:

public class SqlConnection
{
    public void RegisterColumnEncryptionKeyStoreProvidersOnConnection(IDictionary<string, SqlColumnEncryptionKeyStoreProvider> customProviders)
}
public class SqlCommand 
{
    public void RegisterColumnEncryptionKeyStoreProvidersOnCommand(IDictionary<string, SqlColumnEncryptionKeyStoreProvider> customProviders)
}

Statyczny interfejs API pod adresem SqlConnection, SqlConnection.RegisterColumnEncryptionKeyStoreProviders, używany do globalnego rejestrowania niestandardowych dostawców magazynu głównych kluczy, nadal jest obsługiwany. Pamięć podręczna klucza szyfrowania kolumn, przechowywana globalnie, dotyczy tylko globalnie rejestrowanych dostawców.

Pierwszeństwo rejestracji dostawcy magazynu kluczy głównej kolumny

Wbudowani dostawcy magazynów kluczy głównych kolumn, którzy są dostępni dla magazynu certyfikatów systemu Windows, magazynu CNG i dostawcy CSP, są wstępnie zarejestrowani. Nie należy rejestrować żadnych dostawców w wystąpieniach połączenia lub poleceń, jeśli jest wymagany jeden z wbudowanych dostawców magazynu kluczy głównych dla kolumn.

Niestandardowi dostawcy magazynu kluczy głównych mogą być zarejestrowani za pomocą sterownika w trzech różnych warstwach. Poziom globalny jest taki jak teraz. Nowe rejestracje na połączenie i na poziomie polecenia są początkowo puste i można je ustawić więcej niż raz.

Pierwszeństwa trzech rejestracji są następujące:

• Rejestracja na polecenie jest sprawdzana, czy nie jest pusta.
• Jeśli rejestracja na polecenie jest pusta, rejestracja na połączenie jest sprawdzana, czy nie jest pusta.
• Jeśli rejestracja dla połączenia jest pusta, rejestracja globalna jest sprawdzana.

Po znalezieniu dowolnego dostawcy magazynu kluczy na poziomie rejestracji sterownik nie nie powrócić do innych rejestracji w celu wyszukania dostawcy. Jeśli dostawcy są zarejestrowani, ale odpowiedni dostawca nie zostanie znaleziony na danym poziomie hierarchii, zgłaszany jest wyjątek zawierający tylko zarejestrowanych dostawców zweryfikowanych w rejestracji.

Pierwszeństwo pamięci podręcznej dla klucza szyfrowania kolumn

Sterownik nie buforuje kluczy szyfrowania kolumn (CEK) dla niestandardowych dostawców magazynu kluczy zarejestrowanych przy użyciu nowych interfejsów API na poziomie instancji. Dostawcy magazynu kluczy muszą zaimplementować własną pamięć podręczną, aby zwiększyć wydajność. Sterownik wyłącza lokalną pamięć podręczną kluczy szyfrowania kolumn zaimplementowanych przez dostawców niestandardowego magazynu kluczy, jeśli w sterowniku na poziomie globalnym zarejestrowano instancję dostawcy magazynu kluczy.

Wprowadzono również nowy interfejs API w klasie bazowej SqlColumnEncryptionKeyStoreProvider, aby ustawić czas życia pamięci podręcznej.

public abstract class SqlColumnEncryptionKeyStoreProvider
{
    // The default value of Column Encryption Key Cache Time to Live is 0.
    // Provider's local cache is disabled for globally registered providers.
    // Custom key store provider implementation must include column encryption key cache to provide caching support to locally registered providers.
    public virtual TimeSpan? ColumnEncryptionKeyCacheTtl { get; set; } = new TimeSpan(0);
}

Preferencje adresów IP

Wprowadzono nową właściwość połączenia IPAddressPreference w celu określenia preferencji rodziny adresów IP dla sterownika podczas nawiązywania połączeń TCP. Jeśli Transparent Network IP Resolution (w programie .NET Framework) lub Multi Subnet Failover jest ustawiona na true, to ustawienie nie ma wpływu. Dla tej właściwości istnieją trzy akceptowane wartości:

• IPv4First

  • Ta wartość jest wartością domyślną. Sterownik używa najpierw rozpoznanych adresów IPv4. Jeśli żaden z nich nie może zostać pomyślnie połączony, spróbuje rozpoznać adresy IPv6.

• IPv6First

  • Sterownik używa najpierw rozpoznanych adresów IPv6. Jeśli żaden z nich nie może zostać pomyślnie połączony, spróbuje rozpoznać adresy IPv4.

• UsePlatformDefault

  • Sterownik próbuje adresów IP w kolejności otrzymanej z odpowiedzi DNS.

Obsługa platformy docelowej 3.0

• .NET Framework 4.6.1+ (Windows x86, Windows x64)
• .NET Core 2.1+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Informacje o wersji programu Microsoft.Data.SqlClient 2.1

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 2.1 Informacje o wersji.

Nowe funkcje w wersji 2.1

Obsługa wielu platform dla funkcji Always Encrypted

Program Microsoft.Data.SqlClient w wersji 2.1 rozszerza obsługę funkcji Always Encrypted na następujących platformach:

Obsługa funkcji Always Encrypted	Obsługa funkcji Always Encrypted z bezpieczną enklawą	Struktura docelowa	Microsoft.Data.SqlClient, wersja programu	System operacyjny
Tak	Tak	.NET Framework 4.6+	1.1.0+	Windows
Tak	Tak	.NET Core 2.1+	2.1.0+1	Windows, Linux, macOS
Tak	Brak2	.NET Standard 2.0	2.1.0+	Windows, Linux, macOS
Tak	Tak	.NET Standard 2.1+	2.1.0+	Windows, Linux, macOS

Notatka

¹ Przed wersją Microsoft.Data.SqlClient w wersji 2.1 funkcja Always Encrypted jest obsługiwana tylko w systemie Windows.

² Always Encrypted z bezpiecznymi enklawami nie jest obsługiwana na platformie .NET Standard 2.0.

Uwierzytelnianie przepływu kodu urządzenia firmy Microsoft Entra

Program Microsoft.Data.SqlClient w wersji 2.1 zapewnia obsługę uwierzytelniania przepływu kodu urządzenia przy użyciu MSAL.NET. Dokumentacja referencyjna: przepływ udzielania autoryzacji urządzeń OAuth2.0

Przykład parametrów połączenia:

Server=<server>.database.windows.net; Authentication=Active Directory Device Code Flow; Database=Northwind;Encrypt=True

Następujące API umożliwia dostosowanie mechanizmu wywołania zwrotnego przepływu procesu kodowania urządzenia.

public class ActiveDirectoryAuthenticationProvider
{
    // For .NET Framework, .NET Core and .NET Standard targeted applications
    public void SetDeviceCodeFlowCallback(Func<DeviceCodeResult, Task> deviceCodeFlowCallbackMethod)
}

Uwierzytelnianie tożsamości zarządzanej przez Microsoft Entra

Microsoft.Data.SqlClient w wersji 2.1 wprowadza obsługę uwierzytelniania Microsoft Entra przy użyciu tożsamości zarządzanych .

Obsługiwane są następujące słowa kluczowe trybu uwierzytelniania:

• Tożsamość zarządzana usługi Active Directory
• Instalator MSI dla Active Directory (dla kompatybilności między sterownikami MS SQL)

Przykłady parametrów połączenia:

// For System Assigned Managed Identity
"Server={serverURL}; Authentication=Active Directory MSI; Encrypt=True; Initial Catalog={db};"

// For System Assigned Managed Identity
"Server={serverURL}; Authentication=Active Directory Managed Identity; Initial Catalog={db};"

// For User Assigned Managed Identity
"Server={serverURL}; Authentication=Active Directory MSI; Encrypt=True; User Id={ObjectIdOfManagedIdentity}; Initial Catalog={db};"

// For User Assigned Managed Identity
"Server={serverURL}; Authentication=Active Directory Managed Identity; Encrypt=True; User Id={ObjectIdOfManagedIdentity}; Initial Catalog={db};"

Ulepszenia interaktywnego uwierzytelniania Microsoft Entra

Program Microsoft.Data.SqlClient w wersji 2.1 dodaje następujące interfejsy API, aby dostosować środowisko uwierzytelniania Microsoft Entra Interactive:

public class ActiveDirectoryAuthenticationProvider
{
    // For .NET Framework targeted applications only
    public void SetIWin32WindowFunc(Func<IWin32Window> iWin32WindowFunc);

    // For .NET Standard targeted applications only
    public void SetParentActivityOrWindowFunc(Func<object> parentActivityOrWindowFunc);

    // For .NET Framework, .NET Core and .NET Standard targeted applications
    public void SetAcquireAuthorizationCodeAsyncCallback(Func<Uri, Uri, CancellationToken, Task<Uri>> acquireAuthorizationCodeAsyncCallback);

    // For .NET Framework, .NET Core and .NET Standard targeted applications
    public void ClearUserTokenCache();
}

sekcja konfiguracji SqlClientAuthenticationProviders

Microsoft.Data.SqlClient w wersji 2.1 wprowadza nową sekcję konfiguracji, SqlClientAuthenticationProviders (klon istniejącego SqlAuthenticationProviders). Istniejąca sekcja konfiguracji, SqlAuthenticationProviders, jest nadal wspierana ze względu na zgodność wsteczną, gdy zostanie zdefiniowany odpowiedni typ.

Nowa sekcja umożliwia plikom konfiguracji aplikacji zarówno sekcję SqlAuthenticationProviders dla elementu System.Data.SqlClient, jak i sekcję SqlClientAuthenticationProviders dla elementu Microsoft.Data.SqlClient.

Uwierzytelnianie w usłudze Microsoft Entra przy użyciu identyfikatora klienta aplikacji

Program Microsoft.Data.SqlClient w wersji 2.1 wprowadza obsługę przekazywania identyfikatora klienta aplikacji zdefiniowanej przez użytkownika do biblioteki Microsoft Authentication Library. Identyfikator klienta aplikacji jest używany podczas uwierzytelniania za pomocą identyfikatora Entra firmy Microsoft.

Wprowadzono następujące nowe interfejsy API:

1. Nowy konstruktor został wprowadzony w elemencie ActiveDirectoryAuthenticationProvider.
   [Dotyczy wszystkich platform .NET (.NET Framework, .NET Core i .NET Standard)]

   public ActiveDirectoryAuthenticationProvider(string applicationClientId)
   

   Użycie:

   string APP_CLIENT_ID = "<GUID>";
   SqlAuthenticationProvider customAuthProvider = new ActiveDirectoryAuthenticationProvider(APP_CLIENT_ID);
   SqlAuthenticationProvider.SetProvider(SqlAuthenticationMethod.ActiveDirectoryInteractive, customAuthProvider);
   
   using (SqlConnection sqlConnection = new SqlConnection("<connection_string>"))
   {
       sqlConnection.Open();
   }
   

2. Wprowadzono nową właściwość konfiguracji w SqlAuthenticationProviderConfigurationSection i SqlClientAuthenticationProviderConfigurationSection:
   [Dotyczy platform .NET Framework i .NET Core]

   internal class SqlAuthenticationProviderConfigurationSection : ConfigurationSection
   {
       ...
       [ConfigurationProperty("applicationClientId", IsRequired = false)]
       public string ApplicationClientId => this["applicationClientId"] as string;
   }
   
   // Inheritance
   internal class SqlClientAuthenticationProviderConfigurationSection : SqlAuthenticationProviderConfigurationSection
   { ... }
   

   Zastosowanie

   <configuration>
       <configSections>
           <section name="SqlClientAuthenticationProviders"
                            type="Microsoft.Data.SqlClient.SqlClientAuthenticationProviderConfigurationSection, Microsoft.Data.SqlClient" />
       </configSections>
       <SqlClientAuthenticationProviders applicationClientId ="<GUID>" />
   </configuration>
   
   <!--or-->
   
   <configuration>
       <configSections>
           <section name="SqlAuthenticationProviders"
                            type="Microsoft.Data.SqlClient.SqlAuthenticationProviderConfigurationSection, Microsoft.Data.SqlClient" />
       </configSections>
       <SqlAuthenticationProviders applicationClientId ="<GUID>" />
   </configuration>
   

Obsługa klasyfikacji danych w wersji 2

Microsoft.Data.SqlClient w wersji 2.1 wprowadza obsługę informacji "Ranga poufności" klasyfikacji danych. Dostępne są teraz następujące nowe interfejsy API:

public class SensitivityClassification
{
    public SensitivityRank SensitivityRank;
}

public class SensitivityProperty
{
    public SensitivityRank SensitivityRank;
}

public enum SensitivityRank
{
    NOT_DEFINED = -1,
    NONE = 0,
    LOW = 10,
    MEDIUM = 20,
    HIGH = 30,
    CRITICAL = 40
}

Identyfikator procesu serwera dla aktywnej SqlConnection

Program Microsoft.Data.SqlClient w wersji 2.1 wprowadza nową właściwość SqlConnection, ServerProcessId, w aktywnym połączeniu.

public class SqlConnection
{
    // Returns the server process Id (SPID) of the active connection.
    public int ServerProcessId;
}

Obsługa rejestrowania śledzenia w natywnym interfejsie SNI

Microsoft.Data.SqlClient w wersji 2.1 rozszerza istniejącą implementację SqlClientEventSource w celu włączenia śledzenia zdarzeń w SNI.dll. Zdarzenia muszą być przechwytywane przy użyciu narzędzia, takiego jak Xperf.

Śledzenie można włączyć, wysyłając polecenie do SqlClientEventSource, jak pokazano:

// Enables trace events:
EventSource.SendCommand(eventSource, (EventCommand)8192, null);

// Enables flow events:
EventSource.SendCommand(eventSource, (EventCommand)16384, null);

// Enables both trace and flow events:
EventSource.SendCommand(eventSource, (EventCommand)(8192 | 16384), null);

Właściwość dotycząca połączenia o nazwie "Limit czasu polecenia"

Microsoft.Data.SqlClient w wersji 2.1 wprowadza właściwość parametrów połączenia "Limit czasu polecenia", aby zastąpić wartość domyślną 30 sekund. Limit czasu dla indywidualnych poleceń można zmienić za pomocą właściwości CommandTimeout w SqlCommand.

Przykłady parametrów połączenia:

"Server={serverURL}; Initial Catalog={db}; Encrypt=True; Integrated Security=true; Command Timeout=60"

Usuwanie symboli z natywnego interfejsu SNI

Microsoft.Data.SqlClient w wersji 2.1 usunęliśmy symbole wprowadzone w wersji 2.0.0 z Microsoft.Data.SqlClient.SNI.runtime NuGet, począwszy od wersji 2.1.1. Symbole publiczne są teraz publikowane na serwerze symboli firmy Microsoft dla narzędzi takich jak BinSkim, które wymagają dostępu do symboli publicznych.

Source-Linking symboli Microsoft.Data.SqlClient

Począwszy od microsoft.Data.SqlClient w wersji 2.1, symbole Microsoft.Data.SqlClient są połączone ze źródłem i publikowane w programie Microsoft Symbols Server w celu uzyskania ulepszonego środowiska debugowania bez konieczności pobierania kodu źródłowego.

2.1 Obsługa platformy docelowej

• .NET Framework 4.6+ (Windows x86, Windows x64)
• .NET Core 2.1+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Informacje o wersji programu Microsoft.Data.SqlClient 2.0

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 2.0 Informacje o wersji.

Zmiany powodujące niezgodność w wersji 2.0

• Modyfikator dostępu interfejsu dostawcy enklawy SqlColumnEncryptionEnclaveProvider został zmieniony z public na internal.
• Stałe w klasie SqlClientMetaDataCollectionNames zostały zaktualizowane w celu odzwierciedlenia zmian w programie SQL Server.
• Sterownik wykonuje teraz walidację certyfikatu serwera, gdy docelowy program SQL Server wymusza szyfrowanie TLS, co jest ustawieniem domyślnym dla połączeń platformy Azure.
• SqlDataReader.GetSchemaTable() teraz zwraca pusty DataTable zamiast null.
• Sterownik wykonuje teraz zaokrąglanie skali dziesiętnej w celu dopasowania do zachowania programu SQL Server. Aby zapewnić kompatybilność z poprzednimi wersjami, poprzednie zachowanie trunkowania można włączyć za pomocą przełącznika AppContext.
• W przypadku aplikacji .NET Framework zużywających Microsoft.Data.SqlClientpliki SNI.dll pobrane wcześniej do folderów bin\x64 i bin\x86 mają teraz nazwę Microsoft.Data.SqlClient.SNI.x64.dll i Microsoft.Data.SqlClient.SNI.x86.dll i są pobierane do katalogu bin.
• Nowe synonimy właściwości parametrów połączenia zastępują stare właściwości podczas pobierania parametrów połączenia z SqlConnectionStringBuilder na potrzeby spójności. przeczytaj więcej

Nowe funkcje w wersji 2.0

W programie Microsoft.Data.SqlClient 2.0 wprowadzono następujące nowe funkcje.

Odporność na awarie DNS

Sterownik buforuje teraz adresy IP z każdego pomyślnego połączenia z punktem końcowym programu SQL Server obsługującym tę funkcję. Jeśli podczas próby połączenia wystąpi błąd rozpoznawania nazw DNS, sterownik spróbuje nawiązać połączenie przy użyciu buforowanego adresu IP dla tego serwera, jeśli istnieje.

Śledzenie źródła zdarzeń

W tej wersji wprowadzono obsługę przechwytywania dzienników śledzenia zdarzeń na potrzeby debugowania aplikacji. Aby przechwycić te zdarzenia, aplikacje klienckie muszą nasłuchiwać zdarzeń z implementacji EventSource w SqlClient.

Microsoft.Data.SqlClient.EventSource

Aby uzyskać więcej informacji, zobacz, jak włączyć śledzenie zdarzeń w programie SqlClient.

Włączanie sieci zarządzanej w systemie Windows

Nowy przełącznik AppContext, "Switch.Microsoft.Data.SqlClient.UseManagedNetworkingOnWindows", umożliwia korzystanie z zarządzanej implementacji SNI w systemie Windows na potrzeby testowania i debugowania. Ten przełącznik przełącza zachowanie sterownika w celu używania zarządzanego interfejsu SNI w programach .NET Core 2.1+ i .NET Standard 2.0+ w systemie Windows, eliminując wszystkie zależności od bibliotek natywnych dla bibliotek Microsoft.Data.SqlClient.

AppContext.SetSwitch("Switch.Microsoft.Data.SqlClient.UseManagedNetworkingOnWindows", true);

Zobacz Przełączniki AppContext w SqlClient, aby uzyskać pełną listę dostępnych przełączników w sterowniku.

Włączanie funkcji obcinania dziesiętnego

Sterownik zaokrągla domyślnie skalę danych dziesiętnych, tak jak w przypadku programu SQL Server. Aby zachować zgodność z poprzednimi wersjami, można ustawić przełącznik AppContext "Switch.Microsoft.Data.SqlClient.TruncateScaledDecimal" na true.

AppContext.SetSwitch("Switch.Microsoft.Data.SqlClient.TruncateScaledDecimal", true);

Nowe synonimy właściwości parametrów połączenia

Dodano nowe synonimy dla następujących istniejących właściwości ciągu połączenia, aby uniknąć nieporozumień związanych z odstępami wokół właściwości z więcej niż jednym słowem. Stare nazwy właściwości nadal są obsługiwane w celu zapewnienia zgodności z poprzednimi wersjami. Ale nowe właściwości parametrów połączenia są teraz uwzględniane podczas pobierania parametrów połączenia z SqlConnectionStringBuilder.

Istniejąca właściwość łańcucha połączenia	Nowy synonim
Zamiar Aplikacji	Intencja aplikacji
LiczbaPonownychPróbPołączenia	Liczba prób ponownego łączenia
InterwałPonownejPróbyPołączenia	Interwał ponawiania próby połączenia
PoolBlockingPeriod	Okres blokowania puli
Wiele Aktywnych Zestawów Wyników (MARS)	Wiele aktywnych zestawów wyników
MultiSubnetFailover	Failover z wieloma podsieciami
Rozwiązanie Przezroczystej Sieci IP	Przezroczyste rozpoznawanie adresów IP sieci
TrustServerCertificate	Certyfikat serwera zaufania

Właściwość SqlBulkCopy RowsCopied

Właściwość RowsCopied zapewnia dostęp tylko do odczytu do liczby wierszy, które zostały przetworzone w bieżącej operacji kopiowania zbiorczego. Ta wartość może nie być równa ostatniej liczbie wierszy dodanych do tabeli docelowej.

Otwarte przesłonięcia połączenia

Domyślne zachowanie programu SqlConnection.Open() można zastąpić, aby wyłączyć dziesięć-sekundowe opóźnienie i automatyczne ponawianie prób połączenia wyzwalane przez błędy przejściowe.

using(SqlConnection sqlConnection = new SqlConnection("Data Source=(local);Integrated Security=true;Initial Catalog=AdventureWorks;"))
{
    sqlConnection.Open(SqlConnectionOverrides.OpenWithoutRetry);
}

Notatka

To zastąpienie można zastosować do SqlConnection.OpenAsync() od wersji Microsoft.Data.SqlClient 6.0.0.

Obsługa nazwy użytkownika w trybie interaktywnym usługi Active Directory

Nazwę użytkownika można określić w parametrach połączenia w przypadku korzystania z trybu uwierzytelniania interakcyjnego firmy Microsoft dla programów .NET Framework i .NET Core

Ustaw nazwę użytkownika przy użyciu właściwości ciągu połączenia identyfikatora użytkownika lub UID.

"Server=<server name>; Database=<db name>; Authentication=Active Directory Interactive; User Id=<username>;Encrypt=True;"

Wskazówki dotyczące kolejności dla narzędzia SqlBulkCopy

Wskazówki dotyczące kolejności można podać, aby zwiększyć wydajność operacji kopiowania zbiorczego w tabelach z indeksami klastra. Aby uzyskać więcej informacji, zobacz sekcję dotyczącą operacji kopiowania zbiorczego.

Zmiany zależności SNI

Microsoft.Data.SqlClient (.NET Core i .NET Standard) w systemie Windows jest teraz zależny od Microsoft.Data.SqlClient.SNI.runtime, zastępując poprzednią zależność od runtime.native.System.Data.SqlClient.SNI. Nowa zależność dodaje obsługę platformy ARM wraz z już obsługiwanymi platformami Arm64, x64 i x86 w systemie Windows.

Obsługa platformy docelowej 2.0

• .NET Framework 4.6+ (Windows x86, Windows x64)
• .NET Core 2.1+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Windows Arm64, Windows ARM, Linux, macOS)

Informacje o wersji programu Microsoft.Data.SqlClient 1.1.0

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 1.1 Informacje o wersji.

Nowe funkcje w wersji 1.1

Funkcja "Always Encrypted" z użyciem bezpiecznych enklaw

Funkcja Always Encrypted jest dostępna od programu Microsoft SQL Server 2016. Bezpieczne enklawy są dostępne od programu Microsoft SQL Server 2019. Aby użyć funkcji enklawy, parametry połączenia powinny zawierać wymagany protokół zaświadczania i adres URL zaświadczania. Na przykład:

"Attestation Protocol=HGS;Enclave Attestation Url=<attestation_url_for_HGS>"

Aby uzyskać więcej informacji, zobacz:

• obsługa SqlClient dla Always Encrypted
• samouczek : tworzenie aplikacji platformy .NET przy użyciu funkcji Always Encrypted z bezpiecznymi enklawami

1.1 Obsługa platformy docelowej

• .NET Framework 4.6+ (Windows x86, Windows x64)
• .NET Core 2.1+ (Windows x86, Windows x64, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Linux, macOS)

Informacje o wersji programu Microsoft.Data.SqlClient 1.0

Wersja początkowa przestrzeni nazw Microsoft.Data.SqlClient oferuje więcej funkcji w istniejącej przestrzeni nazw System.Data.SqlClient.

Pełne informacje o wersji, w tym zależności, są dostępne w repozytorium GitHub: 1.0 Informacje o wersji.

Nowe funkcje w wersji 1.0

Nowe funkcje w programie .NET Framework 4.7.2 System.Data.SqlClient

• Klasyfikacja danych — dostępna w Azure SQL Database i Microsoft SQL Server 2019.

• obsługi protokołu UTF-8 — dostępne w programie Microsoft SQL Server 2019.

Nowe funkcje w programie .NET Core 2.2 System.Data.SqlClient

• Klasyfikacja danych - dostępna w Azure SQL Database i Microsoft SQL Server 2019.

• obsługa UTF-8 — dostępne w programie Microsoft SQL Server 2019.

• Uwierzytelnianie — tryb uwierzytelniania hasłem Active Directory.

Klasyfikacja danych

Funkcja Klasyfikacja danych wprowadza nowy zestaw interfejsów API, które udostępniają informacje o poufności i klasyfikacji danych w trybie tylko do odczytu dotyczące obiektów uzyskanych za pomocą SqlDataReader, gdy źródło bazowe obsługuje tę funkcję i zawiera metadane dotyczące poufności i klasyfikacji danych . Zobacz przykładową aplikację na stronie Odnajdywanie i klasyfikacja danych w programie SqlClient.

public class SqlDataReader
{
    public Microsoft.Data.SqlClient.DataClassification.SensitivityClassification SensitivityClassification
}

namespace Microsoft.Data.SqlClient.DataClassification
{
    public class ColumnSensitivity
    {
        public System.Collections.ObjectModel.ReadOnlyCollection<Microsoft.Data.SqlClient.DataClassification.SensitivityProperty> SensitivityProperties
    }
    public class InformationType
    {
        public string Id
        public string Name
    }
    public class Label
    {
        public string Id
        public string Name
    }
    public class SensitivityClassification
    {
        public System.Collections.ObjectModel.ReadOnlyCollection<Microsoft.Data.SqlClient.DataClassification.ColumnSensitivity> ColumnSensitivities
        public System.Collections.ObjectModel.ReadOnlyCollection<Microsoft.Data.SqlClient.DataClassification.InformationType> InformationTypes
        public System.Collections.ObjectModel.ReadOnlyCollection<Microsoft.Data.SqlClient.DataClassification.Label> Labels
    }
    public class SensitivityProperty
    {
        public Microsoft.Data.SqlClient.DataClassification.InformationType InformationType
        public Microsoft.Data.SqlClient.DataClassification.Label Label
    }
}

Obsługa protokołu UTF-8

Obsługa protokołu UTF-8 nie wymaga żadnych zmian w kodzie aplikacji. Te zmiany sqlClient optymalizują komunikację klient-serwer, gdy serwer obsługuje protokół UTF-8, a sortowanie kolumn bazowych to UTF-8. Zobacz sekcję UTF-8 w sekcji Co nowego w programie SQL Server 2019.

Zawsze szyfrowane z użyciem bezpiecznych enklaw

Ogólnie rzecz biorąc, istniejąca dokumentacja wykorzystująca System.Data.SqlClient na .NET Framework oraz wbudowanych dostawców magazynu kluczy głównych kolumn powinna teraz współpracować również z .NET Core.

programowanie przy użyciu funkcji Always Encrypted za pomocą programu .NET Framework Data Provider

Always Encrypted: ochrona poufnych danych i przechowywanie kluczy szyfrowania w magazynie certyfikatów systemu Windows

Uwierzytelnianie

Różne tryby uwierzytelniania można określić przy użyciu opcji parametru połączenia Authentication. Aby uzyskać więcej informacji, zobacz dokumentację dla elementu SqlAuthenticationMethod.

Notatka

Niestandardowi dostawcy magazynu kluczy, tacy jak dostawca usługi Azure Key Vault, będą musieli zostać zaktualizowani, aby obsługiwać Microsoft.Data.SqlClient. Podobnie dostawcy enklawy będą również musieli zostać zaktualizowani w celu obsługi klienta Microsoft.Data.SqlClient. Funkcja Always Encrypted jest obsługiwana tylko dla obiektów docelowych .NET Framework i .NET Core. Nie jest obsługiwana w odniesieniu do platformy .NET Standard, ponieważ w programie .NET Standard brakuje pewnych zależności szyfrowania.

Obsługa platformy docelowej 1.0

• .NET Framework 4.6+ (Windows x86, Windows x64)
• .NET Core 2.1+ (Windows x86, Windows x64, Linux, macOS)
• .NET Standard 2.0+ (Windows x86, Windows x64, Linux, macOS)