A Microsoft.Data.SqlClient névtér bemutatása

Töltse le ADO.NET

A Microsoft.Data.SqlClient névtér lényegében a System.Data.SqlClient névtér új verziója. A Microsoft.Data.SqlClient általában ugyanazt az API-t és visszamenőleges kompatibilitást biztosítja a System.Data.SqlClienttel. A System.Data.SqlClientről a Microsoft.Data.SqlClientre való migráláshoz a legtöbb alkalmazás esetében egyszerű. Adjon hozzá NuGet-függőséget a Microsoft.Data.SqlClienthez, és frissítse a hivatkozásokat és using utasításokat a Microsoft.Data.SqlClienthez.

A System.Data.SqlClienthez képest a kevésbé használt API-k között van néhány különbség, amelyek egyes alkalmazásokat érinthetnek. A különbségekhez tekintse meg a hasznos portolási útmutatót.

API-referencia

A Microsoft.Data.SqlClient API részletei megtalálhatóak a .NET API Browser.

Kibocsátási megjegyzések a Microsoft.Data.SqlClient 6.1-hez

A 6.1 új funkciói

Dedikált SQL Server-vektor adattípus támogatása

Mi változott:

• Az MDS és az SQL Server 2025 (17.x) közötti optimalizált vektorkommunikáció, amely egyéni bináris formátumot alkalmaz a TDS protokollon keresztül (#3433, #3443).

• Csökkentett feldolgozási terhelés a meglévő JSON-alapú vektortámogatáshoz képest.

• A 32 bites egypontos lebegőpontos vektorok kezdeti támogatása.

Kinek a előnyei:

• A nagy vektoradatkészleteket mozgató alkalmazások a feldolgozási idő és a memória követelményeinek kedvező javulását látják.
• A vektorspecifikus API-k konzisztens megjelenéssel támogatják a jövőbeli numerikus ábrázolásokat.

Hatás:

• Az SQL Server 2025 használatával a vektorműveletek és a JSON esetében csökkentett átviteli és feldolgozási idő (17.x):

  • Olvasás: 50-szeres fejlesztés
  • Írások: 3,3-szoros fejlesztés
  • Tömeges másolás: 19-szeres fejlesztés
  • (Legfeljebb 1998 méretű vektoroszlopmal és minden művelethez 10 000 rekorddal figyelhető meg.)

• Továbbfejlesztett memóriaigény a JSON-szerializálás/deszerializálás és a sztringreprezentálási bloat megszüntetése miatt.

• A korábbi SQL Server Vector-implementációkkal való visszamenőleges kompatibilitás érdekében előfordulhat, hogy az alkalmazások továbbra is JSON-sztringeket használnak vektoradatok küldéséhez/fogadásához, bár nem látják a korábban említett teljesítménybeli javulást.

Újjáélesztett .NET Standard 2.0-s céltámogatás

Mi változott:

• A .NET Standard 2.0 célzásának támogatása visszatért (#3381)
• A támogatást korábban eltávolították a 6.0-s kiadásban, és a közösség aggályosnak érezte.

Kinek a előnyei:

• Az MDS-től függő kódtárak zökkenőmentesen megcélzhatják az alábbi keretrendszerek bármelyikét:
  • .NET Standard 2.0
  • .NET Framework 4.6.2 vagy újabb
  • .NET 8.0
  • .NET 9.0
• Az alkalmazásoknak továbbra is meg kell céloznia a futtatókörnyezeteket.
  • Az MDS .NET Standard 2.0 cél-keretrendszer támogatása nem tartalmaz tényleges implementációt, és nem használható futtatókörnyezettel.
  • Az alkalmazás buildelési/közzétételi folyamatának mindig a megfelelő MDS .NET/.NET-keretrendszer futtatókörnyezet-implementációt kell választania.
  • Az MDS .NET Standard 2.0 referencia DLL futtatókörnyezetben való üzembe helyezését helytelenül megkísérlő egyéni buildelési/közzétételi műveletek nem támogatottak.

Hatás:

• A .NET Standard 2.0-t célzó kódtárak már nem kapnak figyelmeztetést, például:

  warning NU1701: Package 'Microsoft.Data.SqlClient 6.0.2' was restored using '.NETFramework,Version=v4.6.1, .NETFramework,Version=v4.6.2, .NETFramework,Version=v4.7, .NETFramework,Version=v4.7.1, .NETFramework,Version=v4.7.2, .NETFramework,Version=v4.8, .NETFramework,Version=v4.8.1' instead of the project target framework '.NETStandard,Version=v2.0'. This package may not be fully compatible with your project.
  

Egyéb kiegészítések

• A Fabric-végpontokkal rendelkező speciális burkolatok támogatása hozzáadva. (#3084)

6.1 Célplatform támogatása

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

A teljes kibocsátási megjegyzések, beleértve a függőségeket is, a GitHub-adattárban érhetők el: 6.1 Kibocsátási megjegyzések.

A Microsoft.Data.SqlClient 6.0 kibocsátási megjegyzései

Kompatibilitástörő változások a 6.0-ban

• A .NET Standard támogatása csökkent. #2386
• Megszüntették a támogatást a .NET 6-hoz #2927
• Elvetett UWP-(UAP-) hivatkozások. #2483
• Megszüntették az SQL 2000 ügyféloldali hibakeresési támogatását a .NET-keretrendszerhez #2981, #2940

A 6.0 új funkciói

• JSON-adattípus támogatása #2916, #2892, #2891, #2880, #2882, #2829, #2830
• Hozzáadták a támogatást a .NET 9 #2946-hez.
• A .NET-hez hozzáadták a Microsoft.Data.SqlClient.Diagnostics.SqlClientDiagnostic típust. #2226
• DateOnly és TimeOnly támogatása DataTable strukturált paraméterként. #2258
• Hozzáadva SqlConnectionOverrides támogatása a(z) OpenAsync() API-#2433 számára.
• Hozzáadott lokalizáció cseh, lengyel és török nyelven #2987
• A TokenCredential objektumot azért adták hozzá, hogy kihasználják a tokenek gyorsítótárazási lehetőségeit a ActiveDirectoryAuthenticationProvider-ben. #2380
• Olvasási funkció hozzáadva a NuGet-csomaghoz #2826
• Engedélyezett NuGet-csomagok naplózása NuGet.org naplózási forráson keresztül #3024
• Hozzáadva a(z) hiányzó SqlCommand_BeginExecuteReader kódminta #3009
• Hatókör-nyomkövetés hozzáadva a GenerateSspiClientContext. #2497, #2725

JSON-adattípus támogatása

A JSON-adattípus támogatása mostantól elérhető a Microsoft.Data.SqlClient 6.0-s verzióban. Ez a kiadás a SqlJsonbővítményeként elérhető System.Data.SqlDbTypes típust mutatja be:

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

A JSON-adattípus támogatja az olvasási, írási, streamelési és tömeges másolási műveleteket.

Az SqlClientDiagnostics bemutatása

Új típusok érhetők el a Microsoft.Data.SqlClient.Diagnostics névtérben, amelyek kulcs-érték párok erősen beírt gyűjteményét biztosítják. Ezek a típusok rögzíthetők az illesztőprogram által kibocsátott diagnosztikai események gyűjtésére szolgáló alkalmazások használatával. Ez a kiadás a következő típusokat mutatja be:

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

A kapcsolati felülbírálások támogatása az OpenAsync() API-ban

A SqlConnection.OpenAsync() alapértelmezett viselkedése felülbírálható a tíz másodperces késleltetés és az átmeneti hibák által kiváltott automatikus kapcsolat-újrapróbálkozások letiltásához.

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

6.0 Célplatform támogatása

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

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 6.0 Kibocsátási megjegyzések.

A Microsoft.Data.SqlClient 5.2 kibocsátási megjegyzései

Új funkciók az 5.2-ben

• A SqlDiagnosticListener támogatása a .NET Standard-ben hozzáadva. #1931
• Új tulajdonságot RowsCopied64 adtunk hozzá SqlBulkCopy-hez. #2004További információ
• Új AccessTokenCallBack API-t adott hozzá a SqlConnection. #1260További információ
• A Windowsos .NET-en futó titkosításhoz hozzáadtuk a SuperSocketNetLib beállításjegyzék támogatását. #2047
• Hozzáadták a SqlBatch támogatást a .NET 6+ #1825, #2223Olvasson tovább
• Hozzáadták a Workload Identity hitelesítési támogatást #2159, #2264
• Honosítási támogatás hozzáadva a .NET #2210
• Támogatás a grúz sorrendhez hozzáadva #2194
• A Big Endian-rendszerek támogatása #2170
• Hozzáadva a .NET 8 támogatása #2230
• A .NET főverziótól való függőségeket explicit módon bővítették a System.Runtime.Caching 8.0.0, a System.Configuration.ConfigurationManager 8.0.0 és a System.Diagnostics.DiagnosticSource 8.0.0 esetén. #2303
• Lehetővé tette hibakeresési szimbólumok létrehozását egy külön csomagfájlban #2137

Új tulajdonság RowsCopied64 hozzáadva az SqlBulkCopyhoz

Az SqlBulkCopy-nak van egy új tulajdonsága RowsCopied64, amely támogatja a long értéktípusokat.

A meglévő SqlBulkCopy.RowsCopied viselkedés nem változik. Ha az érték meghaladja a int.MaxValue, RowsCopied negatív számot adhat vissza.

Példahasználat:

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

Új tulajdonság AccessTokenCallBack hozzáadva az SqlConnectionhoz

Az SqlConnection egy új TokenCredential tulajdonság AccessTokenCallBack delegáltként történő bevezetésével támogatja a Func<SqlAuthenticationParameters, CancellationToken,Task<SqlAuthenticationToken>> hitelesítést az összevont hitelesítési hozzáférési jogkivonat visszaadásához.

Példahasználat:

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

Példahasználat:

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 Célplatform támogatása

• .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)

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 5.2 Kibocsátási megjegyzések.

A Microsoft.Data.SqlClient 5.1 kibocsátási megjegyzései

Kompatibilitástörő változások az 5.1-ben

• A .NET Core 3.1 támogatása csökkent. #1704#1823

Új funkciók az 5.1-ben

• Hozzáadott támogatás a DateOnly és TimeOnly számára a SqlParameter értékhez és GetFieldValue-hoz. #1813
• A TLS 1.3 támogatása a .NET Core-hoz és natív SNI-hoz. #1821
• Hozzáadva a(z) ServerCertificate beállítás Encrypt=Mandatory vagy Encrypt=Strictszámára. #1822További információ
• Windows Arm64 támogatás hozzáadva, amikor a .NET keretrendszert célozza. #1828

Kiszolgálói tanúsítvány

A ServerCertificate kapcsolatbeállítás alapértelmezett értéke egy üres sztring. Ha EncryptMandatory vagy Strictértékre van állítva, ServerCertificate megadhatja a fájlrendszer azon elérési útját, amely megfelel a kiszolgáló TLS/SSL-tanúsítványának. A megadott tanúsítványnak pontos egyezésnek kell lennie ahhoz, hogy érvényes legyen. Az elfogadott tanúsítványformátumok a következők: PEM, DERés CER. Íme egy használati példa:

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

5.1 Célplatform támogatása

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

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 5.1 Kibocsátási megjegyzések.

A Microsoft.Data.SqlClient 5.0 kibocsátási megjegyzései

Kompatibilitástörő változások az 5.0-s verzióban

• Megszűnt a támogatás a .NET-keretrendszer 4.6.1-es verziójához #1574
• Függőséget adott hozzá a Microsoft.SqlServer.Server csomaghoz. Ez az új függőség névtérütközéseket okozhat, ha az alkalmazás hivatkozik erre a névtérre, és továbbra is rendelkezik csomaghivatkozásokkal (közvetlen vagy közvetett) a System.Data.SqlClientre a .NET Core-ból.
• Az osztályokat elvetette a Microsoft.Data.SqlClient.Server névtérből, és a Microsoft.SqlServer.Server csomag támogatott típusaira cserélte őket.#1585. Az érintett osztályok és enumerálások a következők:
  • 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
  • (enum) Microsoft.Data.SqlClient.Server.DataAccessKind –> Microsoft.SqlServer.Server.DataAccessKind
  • (enumerálás) Microsoft.Data.SqlClient.Server.Format –> Microsoft.SqlServer.Server.Format
  • (enumeráció) Microsoft.Data.SqlClient.Server.SystemDataAccessKind –> Microsoft.SqlServer.Server.SystemDataAccessKind

Az 5.0 új funkciói

• A TDS8támogatásának hozzáadása megtörtént. A TDS 8 használatához a felhasználóknak meg kell adniuk a Encrypt=Strict értéket a kapcsolati sztringben. #1608További információ
• Hozzáadtak támogatást a szerver SPN és az átváltási szerver SPN megadáshoz a kapcsolaton. #1607További információ
• A .NET Core Windows rendszert célzó aliasok támogatása hozzáadva. #1588További információ
• SqlDataSourceEnumerator hozzáadva. #1430, További információ
• Új AppContext-kapcsolót adott hozzá a nem biztonságos TLS-figyelmeztetések letiltásához. #1457, További információ

TDS 8.0 fokozott biztonság

A TDS 8.0 használatához adja meg a Encrypt=Strict értéket a kapcsolati sztringben. A Szigorú mód letiltja a TrustServerCertificate szolgáltatást (szigorú módban mindig hamisként kezelik). A HostNameInCertificate hozzá lett adva, hogy segítsen néhány szigorú módú forgatókönyvben. A TDS 8.0 megkezdi és folytatja a kiszolgálói kommunikációt egy biztonságos, titkosított TLS-kapcsolaton belül.

Új titkosítási értékek lettek hozzáadva a kapcsolattitkosítási viselkedés tisztázásához. Encrypt=Mandatory egyenértékű Encrypt=True és titkosítja a kapcsolatokat a TDS-kapcsolat egyeztetése során. Encrypt=Optional egyenértékű a Encrypt=False, és csak akkor titkosítja a kapcsolatot, ha a kiszolgáló azt jelzi az ügyfélnek, hogy a TDS-kapcsolat egyeztetése során titkosításra van szükség.

A kiszolgálóhoz való kapcsolatok titkosításáról további információt a Microsoft.Data.SqlClient titkosítása és tanúsítványérvényesítése című témakörben talál.

HostNameInCertificate megadható a kapcsolati sztringben, ha aliasok használatával csatlakozik titkosítással egy olyan kiszolgálóhoz, amelynek kiszolgálótanúsítványa más névvel vagy másodlagos tulajdonosnévvel rendelkezik, mint az ügyfél által a kiszolgáló azonosítására használt név (például DNS-aliasok). Példahasználat: HostNameInCertificate=MyDnsAliasName

Kiszolgáló szolgáltatásazonosító (SPN)

Ha olyan környezetben csatlakozik, amely egyedi tartomány-/erdőtopográfiával rendelkezik, előfordulhat, hogy a kiszolgálói SPN-ekre vonatkozó speciális követelményekkel rendelkezik. A ServerSPN/Server SPN és a FailoverServerSPN/Failover Server SPN kapcsolati karakterlánc-beállításaival felülbírálhatók a tartományi környezetek integrált hitelesítése során használt automatikusan létrehozott kiszolgálói SPN-ek.

SQL-aliasok támogatása

A felhasználók az SQL Server Configuration Managerrel konfigurálhatják az aliasokat. Ezek az aliasok a Windows-beállításjegyzékben vannak tárolva, és már támogatottak a .NET-keretrendszer megcélzásakor. Ez a kiadás támogatja az aliasokat a .NET vagy a .NET Core windowsos megcélzásakor.

SQL-adatforrások számbavételének támogatása

Mechanizmust biztosít az SQL Server összes elérhető példányának számbavételéhez a helyi hálózaton belül.

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

Nem biztonságos TLS-figyelmeztetések letiltása

Biztonsági figyelmeztetés jelenik meg a konzolon, ha az 1.2-nél kisebb TLS-verziót használják a kiszolgálóval való egyeztetéshez. Ezt a figyelmeztetést el lehet tiltani SQL-kapcsolaton, miközben Encrypt = false az alkalmazás indításakor az alábbi AppContext kapcsoló engedélyezésével:

Switch.Microsoft.Data.SqlClient.SuppressInsecureTLSWarning

5.0 Célplatform támogatása

• .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)

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 5.0 Kibocsátási megjegyzések.

A Microsoft.Data.SqlClient 4.1 kibocsátási megjegyzései

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 4.1 Kibocsátási megjegyzések.

A 4.1 új funkciói

Nincs igazolási protokoll bevezetése

A kapcsolati sztringben engedélyezett a None nevű új igazolási protokoll. Ez a protokoll lehetővé teszi, hogy a felhasználók mellőzzék az enklávé hitelesítését a VBS enklávék esetében. Ha ez a protokoll be van állítva, az enklávé igazolási URL-tulajdonság nem kötelező.

Példa kapcsolati karakterláncra:

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

4.1 Célplatform támogatása

• .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)

A Microsoft.Data.SqlClient 4.0 kibocsátási megjegyzései

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 4.0 kibocsátási megjegyzések.

Kompatibilitásbeli változások a 4.0-ban

• Alapértelmezés szerint a(z) Encrypt kapcsolati sztring tulajdonságát true-re módosította. #1210További információ
• Az illesztőprogram mostantól SqlException dob, és ezzel helyettesíti AggregateException az Active Directory hitelesítési módoknál. #1213
• Az elavult Asynchronous Processing kapcsolattulajdonság el lett távolítva a .NET-keretrendszerből. #1148
• El lett távolítva Configurable Retry Logic biztonsági kapcsoló. #1254További információ
• Megszüntették a .NET Core 2.1 támogatását #1272
• [.NET-keretrendszer] Kivétel nem dobódik, ha a kapcsolati karakterláncban meg van adva egy felhasználói azonosító Active Directory Integrated hitelesítéssel #1359.

A 4.0 új funkciói

Alapértelmezett érték titkosítva: igaz

A Encrypt kapcsolatbeállítás alapértelmezett értéke false értékről trueértékre módosult. A felhőalapú adatbázisok egyre növekvő használata és a kapcsolatok biztonságossá tételének szükségessége miatt itt az ideje ennek a kompatibilitástörő változásnak.

Győződjön meg arról, hogy a kapcsolatok sikertelenek, ha titkosításra van szükség

Olyan esetekben, amikor az ügyféltitkosítási kódtárak le voltak tiltva vagy nem érhetők el, lehetséges volt, hogy a titkosítatlan kapcsolatok akkor is létrejönnek, amikor a titkosítás értéke true (igaz), vagy a kiszolgáló titkosítást igényel.

Alkalmazáskörnyezet kapcsolója alapértelmezett rendszerprotokollok használatához

A TLS 1.3-at az illesztőprogram nem támogatja; ezért alapértelmezés szerint el lett távolítva a támogatott protokollok listájából. A felhasználók az alábbi alkalmazáskörnyezet-kapcsoló engedélyezésével visszaállhatnak az operációs rendszer ügyfélprotokolljainak használatára:

Switch.Microsoft.Data.SqlClient.UseSystemDefaultSecureProtocols

Optimalizált paraméterkötés engedélyezése

A Microsoft.Data.SqlClient új SqlCommand API-t vezet be, EnableOptimizedParameterBinding a nagy számú paraméterrel rendelkező lekérdezések teljesítményének javítása érdekében. Ez a tulajdonság alapértelmezés szerint le van tiltva. Ha trueértékre van állítva, a parancs végrehajtásakor a rendszer nem küld paraméterneveket az SQL Server-példánynak.

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

Konfigurálható újrapróbálkozási logikai biztonsági kapcsoló eltávolítása

A "Switch.Microsoft.Data.SqlClient.EnableRetryLogic" alkalmazáskörnyezet kapcsoló már nem szükséges a konfigurálható újrapróbálkozási logikai funkció használatához. A funkció mostantól a gyakorlatban is támogatott. Az opció alapértelmezett viselkedése továbbra is az, hogy nem próbálkozik újra, ezt az ügyfélalkalmazásoknak felül kell bírálniuk az újrapróbálkozások engedélyezése érdekében.

SqlLocalDb megosztott példány támogatása

Az SqlLocalDb megosztott példányai mostantól támogatottak a felügyelt SNI használatakor.

• Lehetséges forgatókönyvek:
  • (localdb)\. (az SqlLocalDb alapértelmezett példányához csatlakozik)
  • (localdb)\<named instance>
  • (localdb)\.\<shared instance name> (*újonnan hozzáadott támogatás)

GetFieldValueAsync<T> és GetFieldValue<T> támogatása XmlReader, TextReader, Stream típushoz

XmlReader, TextReader, Stream típusok mostantól támogatottak GetFieldValueAsync<T> és GetFieldValue<T>használata esetén .

Példahasználat:

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

4.0 Célplatform támogatása

• .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)

Kibocsátási megjegyzések a Microsoft.Data.SqlClient 3.0-hoz

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 3.0 kibocsátási megjegyzések.

Kompatibilitástörő változások a 3.0-ban

• A minimálisan támogatott .NET-keretrendszer verziója a 4.6.1-es verzióra nőtt. A .NET-keretrendszer 4.6.0-s verziója már nem támogatott. #899
• A User Id kapcsolattulajdonsághoz most Client Id szükséges Object Id helyett a User-Assigned Felügyelt identitás#1010-hez. További információ.
• SqlDataReader most üres DBNullhelyett byte[] értéket ad vissza. Az örökölt viselkedés a AppContext#998További információ beállításával engedélyezhető.

A 3.0 új funkciói

Konfigurálható újrapróbálkozás logikája

Ez az új funkció konfigurálható támogatást nyújt az ügyfélalkalmazásoknak az "átmeneti" vagy az "újrapróbálkozási" hibák újrapróbálkozásához. A konfiguráció kód- vagy alkalmazáskonfigurációs fájlokon keresztül végezhető el, és újrapróbálkozási műveletek alkalmazhatók egy kapcsolat megnyitásához vagy egy parancs végrehajtásához. Ez a funkció alapértelmezés szerint le van tiltva, és jelenleg előzetes verzióban érhető el. A támogatás engedélyezéséhez az ügyfélalkalmazások a következő biztonsági kapcsolót kapcsolják be:

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

A .NET AppContext kapcsoló engedélyezése után újrapróbálkozási logikai politika határozható meg SqlConnection és SqlCommand számára egymástól függetlenül, vagy együtt, különböző testreszabási lehetőségek használatával.

Új nyilvános API-kat vezetnek be SqlConnection és SqlCommand egy egyéni SqlRetryLogicBaseProvider-implementáció regisztrálására:

public SqlConnection
{
    public SqlRetryLogicBaseProvider RetryLogicProvider;
}

public SqlCommand
{
    public SqlRetryLogicBaseProvider RetryLogicProvider;
}

Az API-használati példák itt találhatók:

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

Új konfigurációs szakaszok is be lettek vezetve, hogy ugyanezt a regisztrációt elvégezhesse a konfigurációs fájlokból anélkül, hogy módosítania kellene a meglévő kódot:

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

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

Íme egy egyszerű példa az új konfigurációs szakaszok konfigurációs fájlokban való használatára:

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

Másik lehetőségként az alkalmazások implementálhatják a SqlRetryLogicBaseProvider alaposztály saját szolgáltatóját, és regisztrálhatják azt a SqlConnection/SqlCommand.

Eseményszámlálók

A következő számlálók érhetők el a .NET Core 3.1+ és a .NET Standard 2.1+ rendszerű alkalmazásokhoz:

Név	Megjelenítendő név	Leírás
aktív fizikai kapcsolatok	A kiszolgálókhoz jelenleg létesített tényleges aktív kapcsolatok	Az adatbázis-kiszolgálók számára jelenleg megnyitott kapcsolatok száma.
keményen összekapcsolja	Kiszolgálók tényleges csatlakozási sebessége	Az adatbázis-kiszolgálók felé megnyitott másodpercenkénti kapcsolatok száma.
kemény-leválasztások	Tényleges csatlakozásbontási arány a kiszolgálókról	Az adatbázis-kiszolgálókkal másodpercenként végrehajtott kapcsolatbontások száma.
active-soft-connects	A kapcsolatkészletből lekért aktív kapcsolatok	A kapcsolatkészletből már megnyitott kapcsolatok száma.
lágyan kapcsolódik-hez	A kapcsolatkészletből lekért kapcsolatok aránya	A kapcsolatkészletből felhasznált másodpercenkénti kapcsolatok száma.
lágy lekapcsolások	A kapcsolatkészletnek visszaadott kapcsolatok aránya	A kapcsolatkészletbe visszaadott másodpercenkénti kapcsolatok száma.
nem megosztott kapcsolatok száma	A kapcsolatkészletezést nem használó kapcsolatok száma	A nem gyűjtött aktív kapcsolatok száma.
készletezett kapcsolatok száma	A kapcsolatkészlet által felügyelt kapcsolatok száma	A kapcsolatkészletezési infrastruktúra kezelte az aktív kapcsolatok számát.
aktív kapcsolat készlet csoportok száma	Aktív egyedi kapcsolati karakterláncok száma	Az aktív, egyedi kapcsolatkészletcsoportok száma. Ez a számláló az AppDomainben található egyedi kapcsolati sztringek számán alapul.
inaktív kapcsolati készletcsoportok száma	A metszésre váró egyedi kapcsolati karaktersorok száma	A metszésre megjelölt egyedi kapcsolatkészletcsoportok száma. Ez a számláló az AppDomainben található egyedi kapcsolati sztringek számán alapul.
aktív kapcsolatcsomagok száma	Aktív kapcsolatkészletek száma	A kapcsolatkészletek teljes száma.
inaktív kapcsolatkészlet száma	Inaktív kapcsolatkészletek száma	Azon inaktív kapcsolatkészletek száma, amelyeknek nincs legutóbbi tevékenységük, és amelyek elidegenítésre várnak.
aktív kapcsolatok száma	Aktív kapcsolatok száma	A jelenleg használt aktív kapcsolatok száma.
a szabad kapcsolatok száma	Kész kapcsolatok száma a kapcsolatkészletben	A kapcsolatkészletekben használható nyitott kapcsolatok száma.
sztáziskapcsolatok száma	Az aktuálisan készen álló kapcsolatok száma	Azoknak a kapcsolatoknak a száma, amelyek jelenleg egy művelet befejezésére várnak, és amelyek nem használhatók az alkalmazás számára.
visszanyert kapcsolatok száma	A GC-ből visszakövetelt kapcsolatok száma	A hulladékgyűjtés révén visszanyert kapcsolatok száma, ahol az alkalmazás nem hívta meg a Close vagy Dispose függvényeket. Megjegyzés: A kapcsolatok nem zárhatók be vagy nem szüntethetők meg, ami rontja a teljesítményt.

Ezek a számlálók a .NET Core globális CLI-eszközeivel használhatók: dotnet-counters és dotnet-trace a Windowsban, Linuxban és a Windows PerfView-ban, Microsoft.Data.SqlClient.EventSource szolgáltatónévként. További információ: Eseményszámláló értékek lekérése.

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

Azure Identity-függőségek bemutatása

Microsoft.Data.SqlClient mostantól az Azure.Identity könyvtártól függ, hogy tokeneket szerezzen be az "Active Directory kezelt identitás/MSI" és az "Active Directory szolgáltatásfőkapcsolat" hitelesítési módokhoz. Ez a módosítás a következő módosításokat eredményezi a nyilvános felületen:

• Kompatibilitástörő változás

  A "Felhasználói azonosító" kapcsolati tulajdonsághoz mostantól "Ügyfélazonosító" szükséges a "User-Assigned Felügyelt identitás" objektumazonosítója helyett.

• nyilvános API

  Új írásvédett nyilvános tulajdonság: SqlAuthenticationParameters.ConnectionTimeout

• függőség

  Azure.Identity v1.3.0

Az eseménykövetés fejlesztései a SNI.dll

Microsoft.Data.SqlClient.SNI (.NET-keretrendszer-függőség) és Microsoft.Data.SqlClient.SNI.runtime (.NET Core/Standard-függőség) verziókat v3.0.0-preview1.21104.2-re frissítettük. Az SNI.dll eseménykövetése már nem engedélyezett egy ügyfélalkalmazáson keresztül. Egy munkamenet feliratkozása a Microsoft.Data.SqlClient.EventSource szolgáltatóra olyan eszközök, mint a xperf vagy a perfview révén elegendő. További információ: Natív SNI-eseménykövetési támogatása.

A sorverzió null értékű viselkedésének engedélyezése

SqlDataReader üres DBNullhelyett byte[] értéket ad vissza. Az örökölt viselkedés engedélyezéséhez engedélyeznie kell a következő AppContext kapcsolót az alkalmazás indításakor: "Switch.Microsoft.Data.SqlClient.LegacyRowVersionNullBehavior"

A Microsoft Entra alapértelmezett hitelesítésének támogatása

Jegyzet

Bár a Microsoft Entra ID az Azure Active Directory (Azure AD) új neve, a meglévő környezetek megzavarásának megakadályozása érdekében az Azure AD továbbra is megmarad néhány rögzített elemben, például felhasználói felületi mezőkben, kapcsolatszolgáltatókban, hibakódokban és parancsmagokban. Ebben a cikkben a két név felcserélhető.

Ez a pr egy új SQL Authentication metódust vezet be, Az Active Directory alapértelmezett. Ez a hitelesítési mód kibővíti a Microsoft Entra ID-val történő felhasználói hitelesítés lehetőségeit, kibővíti a bejelentkezési megoldásokat az ügyfélkörnyezetre, a Visual Studio Code-ra, a Visual Studio-ra, az Azure CLI-re stb.

Ezzel a hitelesítési móddal a meghajtó a "DefaultAzureCredential" átadásával szerez be egy hozzáférési tokent az Azure Identity könyvtárból. Ez a mód az alábbi hitelesítő adattípusok használatával próbál hozzáférési jogkivonatot beszerezni a következő sorrendben:

• EnvironmentCredential
  • Engedélyezi a Microsoft Entra-azonosítóval való hitelesítést ügyfél- és titkos kód, felhasználónév és jelszó használatával, a következő környezeti változókban konfigurált részletekkel: AZURE_TENANT_ID, AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_CLIENT_CERTIFICATE_PATH, AZURE_USERNAME, AZURE_PASSWORD (További részletek)
• ManagedIdentityCredential
  • A Microsoft Entra-azonosítóval való hitelesítést az üzembehelyezési környezethez hozzárendelt felügyelt identitás használatával próbálja meg elvégezni. A "felhasználó által hozzárendelt felügyelt identitás" "Ügyfélazonosítója" kerül beolvasásra a "Felhasználói azonosító" kapcsolat tulajdonságából.
• SharedTokenCacheCredential
  • A Microsoft-alkalmazások között megosztott helyi gyorsítótárban lévő tokenekkel hitelesít.
• VisualStudioCredential
  • Hitelesítés engedélyezése a Microsoft Entra-azonosítóval a Visual Studióból származó adatok használatával
• VisualStudioCodeCredential
  • Engedélyezi a Microsoft Entra-azonosítóval való hitelesítést a Visual Studio Code-ból származó adatok használatával.
• AzureCliCredential
  • Engedélyezi a Microsoft Entra ID-val való hitelesítést az Azure CLI használatával a hozzáférési jogkivonat beszerzéséhez.

Az InteractiveBrowserCredential le van tiltva az "Active Directory Alapértelmezett" illesztőprogram megvalósításában, és az "Active Directory Interactive" az egyetlen lehetőség az MFA/Interaktív hitelesítéssel történő token megszerzésére.

A további testreszabási lehetőségek jelenleg nem érhetők el.

Egyéni főkulcs-tároló szolgáltatói regisztrációs fejlesztései

A Microsoft.Data.SqlClient mostantól jobban szabályozhatja, hogy a főkulcstár-szolgáltatók hol érhetők el az alkalmazásokban, hogy jobban támogassák a több-bérlős alkalmazásokat és az oszloptitkosítás/-visszafejtés használatát. Az alábbi API-k kerülnek bevezetésre az egyéni főkulcstár-szolgáltatók SqlConnection és SqlCommandpéldányain történő regisztrációjának engedélyezése céljából.

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

Az egyéni főkulcstár-szolgáltatók globális regisztrálásához használt SqlConnection, SqlConnection.RegisterColumnEncryptionKeyStoreProvidersstatikus API-ja továbbra is támogatott. A globálisan fenntartott oszloptitkosítási kulcs gyorsítótára csak a globálisan regisztrált szolgáltatókra vonatkozik.

Oszlopok főkulcstároló szolgáltatójának regisztrációs prioritása

A Windows Tanúsítványtárolóhoz, a CNG-tárolóhoz és a CSP-hez elérhető beépített oszlop-főkulcstár-szolgáltatók előregisztráltak. A kapcsolat- vagy parancspéldányokon nem lehet szolgáltatót regisztrálni, ha valamelyik beépített oszlop főkulcstároló-szolgáltatóra van szükség.

Az egyéni főkulcstár-szolgáltatók három különböző rétegben regisztrálhatók az illesztőprogrammal. A globális szint a jelenlegihez hasonlóan működik. Az új kapcsolatonkénti és parancsszintű regisztrációk kezdetben üresek, és több alkalommal is beállíthatók.

A három regisztráció elsőbbsége a következő:

• A rendszer ellenőrzi a parancsonkénti regisztrációt, ha nem üres.
• Ha a parancsonkénti regisztráció üres, akkor a rendszer ellenőrzi a kapcsolatonkénti regisztrációt, ha nem üres.
• Ha a kapcsolatonkénti regisztráció üres, a rendszer ellenőrzi a globális regisztrációt.

Ha egy kulcstároló-szolgáltatót a regisztrációs szinten talál, az illesztőprogram nem fog visszaállni a többi regisztrációra a szolgáltató kereséséhez. Ha a szolgáltatók regisztrálva vannak, de a megfelelő szolgáltató nem található meg egy adott szinten, kivétel lesz dobva, amely a regisztrált szolgáltatókat tartalmazza az ellenőrzött regisztrációban.

Oszloptitkosítási kulcs gyorsítótárának elsőbbsége

Az illesztőprogram nem gyorsítótárazza az oszloptitkosítási kulcsokat (CEK-kat) az új példányszintű API-k használatával regisztrált egyéni kulcstároló-szolgáltatók számára. A fő tárolószolgáltatóknak saját gyorsítótárat kell implementálniuk a teljesítmény eléréséhez. Az illesztőprogram letiltja az egyéni kulcstároló-szolgáltatók által implementált oszloptitkosítási kulcsok helyi gyorsítótárát, ha a kulcstároló-szolgáltató példánya regisztrálva van az illesztőprogramban globális szinten.

Az SqlColumnEncryptionKeyStoreProvider alaposztályon egy új API-t is bevezettek a gyorsítótár élettartamának beállításához:

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

IP-cím beállítás

A TCP-kapcsolatok létrehozásakor egy új kapcsolati tulajdonság IPAddressPreference kerül bevezetésre, amely meghatározza az illesztőprogram IP-címcsalád-beállításait. Ha Transparent Network IP Resolution (.NET-keretrendszerben) vagy Multi Subnet Failovertruevan beállítva, ennek a beállításnak nincs hatása. A tulajdonságnak három elfogadott értéke van:

• IPv4First

  • Ez az alapértelmezett érték. Az illesztőprogram először feloldott IPv4-címeket használ. Ha egyikhez sem lehet sikeresen csatlakozni, megpróbálja feloldani az IPv6-címeket.

• IPv6First

  • Az illesztőprogram először feloldott IPv6-címeket használ. Ha egyikhez sem lehet sikeresen kapcsolódni, megpróbál csatlakozni a már feloldott IPv4-címekhez.

• UsePlatformDefault

  • Az illesztőprogram a DNS-feloldási választól kapott sorrendben próbálja meg az IP-címeket.

3.0 Célplatform támogatása

• .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)

Kibocsátási megjegyzések a Microsoft.Data.SqlClient 2.1-hez

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 2.1 Kibocsátási megjegyzések.

A 2.1 új funkciói

Platformfüggetlen támogatás az Always Encryptedhez

A Microsoft.Data.SqlClient v2.1 támogatja az Always Encrypted szolgáltatást a következő platformokon:

Always Encrypted támogatása	Az "Always Encrypted" támogatása biztonságos enklávéval	Cél-keretrendszer	Microsoft.Data.SqlClient-verzió	Operációs rendszer
Igen	Igen	.NET-keretrendszer 4.6+	1.1.0+	Windows
Igen	Igen	.NET Core 2.1+	2.1.0+1	Windows, Linux, macOS
Igen	Nincs2	.NET Standard 2.0	2.1.0+	Windows, Linux, macOS
Igen	Igen	.NET Standard 2.1+	2.1.0+	Windows, Linux, macOS

¹ A Microsoft.Data.SqlClient 2.1-es verziója előtt az Always Encrypted csak Windows rendszeren támogatott.
² Az Always Encrypted biztonságos enklávékkal nem támogatott a .NET Standard 2.0 alatt.

Microsoft Entra Device Code Flow-hitelesítés

A Microsoft.Data.SqlClient v2.1 támogatja a "Device Code Flow" hitelesítést az MSAL.NET-tel. Referenciadokumentáció: OAuth2.0 eszközengedélyezési folyamat

Példa kapcsolati karakterláncra:

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

A következő API lehetővé teszi az eszközkód-visszahívási mechanizmus testreszabását:

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

Microsoft Entra által felügyelt identitáshitelesítés

A Microsoft.Data.SqlClient v2.1 támogatja a Microsoft Entra-hitelesítést felügyelt identitásokkal.

A következő hitelesítési módú kulcsszavak támogatottak:

• Active Directory-ban felügyelt identitás
• Active Directory MSI (ms sql-illesztőprogramok közötti kompatibilitáshoz)

Kapcsolati karakterlánc példák:

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

A Microsoft Entra Interaktív hitelesítés fejlesztései

A Microsoft.Data.SqlClient v2.1 a következő API-kat adja hozzá a Microsoft Entra Interaktív hitelesítési felület testreszabásához:

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

SqlClientAuthenticationProviders konfigurációs szakasz

A Microsoft.Data.SqlClient v2.1 új konfigurációs szakaszt vezet be, SqlClientAuthenticationProviders (a meglévő SqlAuthenticationProvidersklónja). A meglévő konfigurációs szakasz SqlAuthenticationProviderstovábbra is támogatott a visszamenőleges kompatibilitáshoz a megfelelő típus definiálásakor.

Az új szakasz lehetővé teszi, hogy az alkalmazáskonfigurációs fájlok tartalmazzák mind a System.Data.SqlClient SqlAuthenticationProviders szakaszát, mind a Microsoft.Data.SqlClient SqlClientAuthenticationProviders szakaszát.

Microsoft Entra-hitelesítés alkalmazásügyfél-azonosító használatával

A Microsoft.Data.SqlClient v2.1 bevezeti a felhasználó által definiált alkalmazás ügyfél-azonosítójának támogatását a Microsoft Authentication Library számára. Az alkalmazásügyfél-azonosító a Microsoft Entra-azonosítóval való hitelesítéskor használatos.

A következő új API-k jelennek meg:

1. Új konstruktor lett bevezetve az ActiveDirectoryAuthenticationProviderben:

   A következőkre vonatkozik: Minden .NET-platform (.NET-keretrendszer, .NET Core és .NET Standard)

   public ActiveDirectoryAuthenticationProvider(string applicationClientId)
   

   Használat:

   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. Új konfigurációs tulajdonság került bevezetésre SqlAuthenticationProviderConfigurationSection és SqlClientAuthenticationProviderConfigurationSection:

   A következőkre vonatkozik: .NET-keretrendszer és .NET Core

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

   Használat:

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

Adatbesorolás v2 támogatása

A Microsoft.Data.SqlClient v2.1 támogatja az adatbesorolás "Bizalmassági rangsor" információit. A következő új API-k érhetők el:

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
}

Aktív munkamenet-azonosító a SqlConnection-hoz

A Microsoft.Data.SqlClient v2.1 egy új SqlConnection tulajdonságot vezet be, ServerProcessIdegy aktív kapcsolaton.

public class SqlConnection
{
    // Returns the session ID (SPID) of the active connection.
    public int ServerProcessId;
}

Nyomkövetési naplózás támogatása natív SNI-ben

A Microsoft.Data.SqlClient v2.1 kibővíti a meglévő SqlClientEventSource implementációt, hogy lehetővé tegye az eseménykövetést SNI.dll. Az eseményeket egy olyan eszközzel kell rögzíteni, mint az Xperf.

A nyomkövetés engedélyezhető úgy, hogy egy parancsot küld a SqlClientEventSource az ábrán látható módon:

// 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);

"Command Timeout" kapcsolati karakterlánc tulajdonság

A Microsoft.Data.SqlClient v2.1 bemutatja a "Command Timeout" kapcsolati sztring tulajdonságot, amely a 30 másodperces alapértelmezett időkorlát felülírására szolgál. Az egyes parancsok időtúllépése felülírható az CommandTimeout SqlCommand tulajdonságával.

Kapcsolati karakterlánc példák:

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

Szimbólumok eltávolítása a natív SNI-ből

A Microsoft.Data.SqlClient v2.1 verzióban eltávolítottuk az v2.0.0 alatt bevezetett szimbólumokat a Microsoft.Data.SqlClient.SNI.runtime NuGet csomagból, kezdődően a v2.1.1verzióval. A nyilvános szimbólumok mostantól közzé vannak téve a Microsoft Symbols Serveren olyan eszközök esetében, mint a BinSkim, amelyek nyilvános szimbólumokhoz való hozzáférést igényelnek.

Microsoft.Data.SqlClient szimbólumok forráshivatkozása

A Microsoft.Data.SqlClient 2.1-től kezdődően a Microsoft.Data.SqlClient szimbólumok forráshoz vannak kapcsolva, és közzé vannak téve a Microsoft Symbols Serveren, hogy a hibakeresési folyamat a forráskód letöltése nélkül is elvégezhető legyen.

2.1 Célplatform támogatása

• .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)

Kibocsátási megjegyzések a Microsoft.Data.SqlClient 2.0-hoz

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 2.0 kibocsátási megjegyzések.

Kompatibilitástörő változások a 2.0-ban

• Az enklávészolgáltatói felület hozzáférési módosítóját SqlColumnEncryptionEnclaveProviderpublic-ról internal- ra módosítottuk.
• A SqlClientMetaDataCollectionNames osztály állandói frissültek az SQL Server változásainak megfelelően.
• Az illesztő ekkor elvégzi a kiszolgálótanúsítvány-ellenőrzést, amikor a cél SQL Server TLS-titkosítást kényszerít ki, ami az Azure-kapcsolatok alapértelmezett értéke.
• SqlDataReader.GetSchemaTable() most egy üres DataTable ad vissza, ehelyett null.
• Az illesztő mostantól decimális skálázási kerekítést hajt végre az SQL Server viselkedésének megfelelően. A visszamenőleges kompatibilitás érdekében a csonkolás korábbi viselkedése appContext kapcsolóval engedélyezhető.
• A Microsoft.Data.SqlClient használó .NET-keretrendszer-alkalmazások esetében a korábban a bin\x64 és bin\x86 mappába letöltött SNI.dll fájlok neve mostantól Microsoft.Data.SqlClient.SNI.x64.dll és Microsoft.Data.SqlClient.SNI.x86.dll, és a bin könyvtárba lesznek letöltve.
• Az új kapcsolati sztringtulajdonság szinonimák lecserélik a régi tulajdonságokat a SqlConnectionStringBuilder-ból történő kapcsolati sztring lekérésekor a konzisztencia érdekében. További információ

A 2.0 új funkciói

A Microsoft.Data.SqlClient 2.0-ban az alábbi új funkciók jelentek meg.

DNS-hibák elleni ellenállóképesség

Az illesztő mostantól gyorsítótárazza az IP-címeket minden sikeres kapcsolatról egy olyan SQL Server-végpontra, amely támogatja a funkciót. Ha a kapcsolati kísérlet során DNS-feloldási hiba történik, az illesztő megpróbál kapcsolatot létesíteni a kiszolgáló gyorsítótárazott IP-címével, ha van ilyen.

EventSource-nyomkövetés

Ez a kiadás támogatja az események nyomkövetési naplóinak rögzítését az alkalmazások hibakereséséhez. Az események rögzítéséhez az ügyfélalkalmazásoknak figyelniük kell az SqlClient EventSource-implementációjának eseményeit:

Microsoft.Data.SqlClient.EventSource

További információ: Eseménykövetés engedélyezése az SqlClient.

Felügyelt hálózatkezelés engedélyezése Windows rendszeren

Egy új AppContext-kapcsoló, "Switch.Microsoft.Data.SqlClient.UseManagedNetworkingOnWindows"lehetővé teszi a felügyelt SNI-implementáció használatát Windows rendszeren tesztelési és hibakeresési célokra. Ez a kapcsoló bekapcsolja az illesztőprogram viselkedését, hogy felügyelt SNI-t használjon .NET Core 2.1+ és .NET Standard 2.0+ projektekben Windows rendszeren, így kiküszöböli a Microsoft.Data.SqlClient-kódtár natív kódtáraktól való függőségeit.

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

Az illesztőprogramban elérhető kapcsolók teljes listáját az SqlClient AppContext kapcsolói között találja.

Decimális csonkolás működésének engedélyezése

A meghajtó alapértelmezés szerint kerekíti a decimális adatskálát, ahogyan azt az SQL Server is teszi. A visszamenőleges kompatibilitás érdekében állítsa a "Switch.Microsoft.Data.SqlClient.TruncateScaledDecimal" AppContext kapcsolót igaz értékre.

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

Új kapcsolat karakterlánc tulajdonság szinonimái

Az alábbi meglévő kapcsolati sztring tulajdonságok számára új szinonimákat adtunk hozzá, hogy elkerüljük a több szóból álló tulajdonságok körüli szóközökkel kapcsolatos félreértéseket. A régi tulajdonságnevek továbbra is támogatottak a visszamenőleges kompatibilitás érdekében. Az új kapcsolati sztring tulajdonságai azonban mostantól szerepelnek, amikor a kapcsolati sztringet a SqlConnectionStringBuilder-ból lekérjük.

Meglévő kapcsolat karakterlánc tulajdonság	Új szinonimák
Alkalmazási szándék	Alkalmazás szándéka
ConnectRetryCount	Kapcsolódási újrapróbálkozások száma
Újrakapcsolódási intervallum	Csatlakozás újrapróbálkozási intervalluma
MedenceZárolásiIdőszak	Készlet blokkolási időszaka
Többszörös Aktív Eredménykészletek (MultipleActiveResultSets)	Több aktív eredményhalmaz
MultiSubnetFailover	Több alhálózat átváltás
ÁtlátszóHálózatiIPFeloldás	Transzparens hálózati IP-felbontás
MegbízhatóSzerverTanúsítvány	Megbízhatósági kiszolgáló tanúsítványa

SqlBulkCopy RowsCopied tulajdonság

A RowsCopied tulajdonság csak olvasható hozzáférést biztosít a folyamatban lévő tömeges másolási művelet során feldolgozott sorok számához. Ez az érték nem feltétlenül egyenlő a céltáblához hozzáadott sorok végső számával.

Kapcsolatnyitási módosítások

Az SqlConnection.Open() alapértelmezett viselkedése felülbírálható a tíz másodperces késleltetés és az átmeneti hibák által kiváltott automatikus kapcsolat-újrapróbálkozások letiltásához.

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

Jegyzet

Ez a felülbírálás a SqlConnection.OpenAsync() esetén a Microsoft.Data.SqlClient v6.0.0-tól kezdődően alkalmazható.

Felhasználónév-támogatás az Active Directory Interaktív módhoz

Felhasználónév megadható a kapcsolati sztringben, ha a Microsoft Entra Interaktív hitelesítési módot használja a .NET-keretrendszerhez és a .NET Core-hoz is

Állítson be egy felhasználónevet a felhasználói azonosító vagy UID kapcsolati string tulajdonsága megadásával:

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

Rendelési tippek az SqlBulkCopyhoz

A rendelési tippeket a fürtözött indexekkel rendelkező táblák tömeges másolási műveleteinek teljesítményének javítása érdekében lehet megadni. További információért lásd a tömeges másolási műveletek szakaszt.

SNI-függőségek változásai

A Windows rendszeren futó Microsoft.Data.SqlClient (.NET Core és .NET Standard) mostantól a Microsoft.Data.SqlClient.SNI.runtimefüggőségtől függ, lecserélve a korábbi runtime.native.System.Data.SqlClient.SNIfüggőséget. Az új függőség támogatja az ARM-platformot, valamint a windowsos Arm64, x64 és x86 platformokat.

2.0 Célplatform támogatása

• .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)

A Microsoft.Data.SqlClient 1.1.0 kibocsátási megjegyzései

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 1.1 Kibocsátási megjegyzések.

Új funkciók az 1.1-ben

"Biztonságos enklávékkal történő Always Encrypted"

Az Always Encrypted a Microsoft SQL Server 2016-tól érhető el. A biztonságos enklávék a Microsoft SQL Server 2019-től érhetők el. Az enklávé funkció használatához a kapcsolati sztringeknek tartalmazniuk kell a szükséges igazolási protokollt és az igazolási URL-címet. Például:

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

További információ:

• Az Always Encrypted használata az SQL Serverhez készült Microsoft .NET-adatszolgáltatóval
• oktatóanyag: .NET-alkalmazás fejlesztése az Always Encrypted használatával biztonságos enklávékkal

1.1 Célplatform támogatása

• .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)

A Microsoft.Data.SqlClient 1.0 kibocsátási megjegyzései

A Microsoft.Data.SqlClient névtér kezdeti kiadása több funkciót kínál a meglévő System.Data.SqlClient névtéren keresztül.

A GitHub-adattárban teljes kibocsátási megjegyzések érhetők el, beleértve a függőségeket is: 1.0 Kibocsátási megjegyzések.

Az 1.0 új funkciói

Új funkciók a .NET-keretrendszer 4.7.2 System.Data.SqlClient használatával

• Adatbesorolás – Elérhető az Azure SQL Database-ben és a Microsoft SQL Server 2019-ben.

• UTF-8 támogatási – Elérhető a Microsoft SQL Server 2019-ben.

A .NET Core 2.2 System.Data.SqlClient új funkciói

• Adatbesorolás – Elérhető az Azure SQL Database-ben és a Microsoft SQL Server 2019-ben.

• UTF-8 támogatási – Elérhető a Microsoft SQL Server 2019-ben.

• Hitelesítés – Active Directory jelszó hitelesítési mód.

Adatbesorolás

Az adatbesorolás új API-készletet biztosít, amely lehetővé teszi az írásvédett adatérzékenységi és osztályozási információk elérését az SqlDataReaderen keresztül lekért objektumokról, amikor az alapul szolgáló forrás támogatja a funkciót, és tartalmazza a metaadatokat adatérzékenységről és osztályozásról. Tekintse meg a mintaalkalmazást Data Discovery and Classification in 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
    }
}

UTF-8-támogatás

Az UTF-8 támogatása nem igényel alkalmazáskód-módosítást. Ezek az SqlClient-módosítások optimalizálják az ügyfél-kiszolgáló kommunikációt, ha a kiszolgáló támogatja az UTF-8-at, és az alapul szolgáló oszlopeloszlás UTF-8. Tekintse meg az UTF-8 szakaszt az "Mi újdonság az SQL Server 2019 " részben.

"Biztonságos enklávékkal történő Always Encrypted"

A System.Data.SqlClientet a .NET-keretrendszeren és a beépített oszlop főkulcstároló-szolgáltatókat használó meglévő dokumentációnak most már a .NET Core-nal is működnie kell.

• Az Always Encrypted használata az SQL Serverhez készült .NET-keretrendszer adatszolgáltatójával
• Always Encrypted: Bizalmas adatok védelme és titkosítási kulcsok tárolása a Windows tanúsítványtárolóban

Hitelesítés

Különböző hitelesítési módok a Hitelesítési kapcsolati sztring beállítással adhatók meg. További információt az SqlAuthenticationMethod dokumentációjában talál.

Az egyéni kulcstároló-szolgáltatókat, például az Azure Key Vault szolgáltatót frissíteni kell a Microsoft.Data.SqlClient támogatásához. Hasonlóképpen az enklávészolgáltatókat is frissíteni kell a Microsoft.Data.SqlClient támogatásához.

Az Always Encrypted csak .NET-keretrendszer és .NET Core-célok esetén támogatott. Nem támogatott a .NET Standarddal szemben, mivel a .NET Standardból hiányoznak bizonyos titkosítási függőségek.

1.0 Célplatform támogatása

• .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)