docs: Migrate System.Data.SqlClient to Microsoft.Data.SqlClient in CLR UDT/UDA articles

Author: VanMSFT

docs/relational-databases/clr-integration-database-objects-user-defined-functions/clr-user-defined-aggregate-invoking-functions.md

@@ -3,7 +3,7 @@ title: "Invoking CLR User-Defined Aggregate Functions"
 description: In SQL Server CLR integration, use Transact-SQL SELECT to invoke CLR user-defined aggregates, subject to the rules that apply to system aggregate functions.
 author: rwestMSFT
 ms.author: randolphwest
-ms.date: 12/27/2024
+ms.date: 03/19/2026
 ms.service: sql
 ms.subservice: clr
 ms.topic: "reference"
@@ -26,7 +26,7 @@ The following additional rules apply:
 
 - The current user must have `EXECUTE` permission on the user-defined aggregate.
 
-- User-defined aggregates must be invoked using a two-part name in the form of <schema_name>.<udagg_name>.
+- User-defined aggregates must be invoked by using a two-part name in the form of <schema_name>.<udagg_name>.
 
 - The argument type of the user-defined aggregate must match or be implicitly convertible to the *input_type* of the aggregate, as defined in the `CREATE AGGREGATE` statement.
 
@@ -210,7 +210,7 @@ CREATE AGGREGATE MyAgg(@input NVARCHAR (200))
 > [!NOTE]  
 > Visual C++ database objects, such as scalar-valued functions, that have been compiled with the `/clr:pure` compiler option aren't supported for execution in [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)].
 
-As with most aggregates, the bulk of the logic is in the `Accumulate` method. Here, the string that is passed in as a parameter to the `Accumulate` method is appended to the `StringBuilder` object that was initialized in the `Init` method. Assuming that the `Accumulate` method wasn't already called, a comma is also appended to the `StringBuilder` before appending the passed-in string. At the conclusion of the computational tasks, the `Terminate` method is called, which returns the `StringBuilder` as a string.
+As with most aggregates, the bulk of the logic is in the `Accumulate` method. Here, the string that is passed in as a parameter to the `Accumulate` method is appended to the `StringBuilder` object that was initialized in the `Init` method. Assuming that the `Accumulate` method wasn't already called, a comma is also appended to the `StringBuilder` before appending the passed-in string. When computation finishes, the `Terminate` method is called, which returns the `StringBuilder` as a string.
 
 For example, consider a table with the following schema:
 
@@ -258,7 +258,6 @@ The following sample shows an aggregate that has two parameters on the `Accumula
 ```csharp
 using System;
 using System.Data;
-using System.Data.SqlClient;
 using System.Data.SqlTypes;
 using Microsoft.SqlServer.Server;
 
@@ -339,7 +338,6 @@ public struct WeightedAvg
 ```vb
 Imports System
 Imports System.Data
-Imports System.Data.SqlClient
 Imports System.Data.SqlTypes
 Imports Microsoft.SqlServer.Server
 Imports System.Runtime.InteropServices
@@ -411,7 +409,7 @@ End Class
 
 ---
 
-After you compile the [!INCLUDE [c-sharp-md](../../includes/c-sharp-md.md)] or [!INCLUDE [visual-basic-md](../../includes/visual-basic-md.md)] .NET source code, run the following [!INCLUDE [tsql](../../includes/tsql-md.md)]. This script assumes that the DLL is called WghtAvg.dll and is in the root directory of your C drive. A database called test is also assumed.
+After you compile the [!INCLUDE [c-sharp-md](../../includes/c-sharp-md.md)] or [!INCLUDE [visual-basic-md](../../includes/visual-basic-md.md)] .NET source code, run the following [!INCLUDE [tsql](../../includes/tsql-md.md)]. This script assumes that the DLL is called WghtAvg.dll and is in the root directory of your C drive. It also assumes a database called test exists.
 
 ```sql
 USE test;

docs/relational-databases/clr-integration-database-objects-user-defined-types/accessing-user-defined-types-in-ado-net.md

@@ -3,7 +3,7 @@ title: "Accessing User-Defined Types in ADO.NET"
 description: UDTs, written in .NET Framework CLR languages, allow a SQL Server database to store objects and custom data structures. In ADO.NET, a provider exposes UDTs.
 author: rwestMSFT
 ms.author: randolphwest
-ms.date: 12/27/2024
+ms.date: 03/19/2026
 ms.service: sql
 ms.subservice: clr
 ms.topic: "reference"
@@ -20,11 +20,11 @@ User-defined types (UDTs) are written using any of the languages supported by th
 
 The data is exposed as public members of a .NET Framework class or structure, and behaviors are defined by methods of the class or structure. A UDT can be used as the column definition of a table, as a variable in a [!INCLUDE [tsql](../../includes/tsql-md.md)] batch, or as an argument of a [!INCLUDE [tsql](../../includes/tsql-md.md)] function or stored procedure.
 
-In ADO.NET, the `System.Data.SqlClient` provider exposes UDTs in the following ways:
+In ADO.NET, the `Microsoft.Data.SqlClient` provider exposes UDTs in the following ways:
 
-- Through the `System.Data.SqlClient.SqlDataReader` as an object.
+- Through the `Microsoft.Data.SqlClient.SqlDataReader` as an object.
 - Through the `SqlDataReader` as raw bytes.
-- As a parameter of a `System.Data.SqlClient.SqlParameter` object.
+- As a parameter of a `Microsoft.Data.SqlClient.SqlParameter` object.
 
 ## In this section
 

docs/relational-databases/clr-integration-database-objects-user-defined-types/accessing-user-defined-types-retrieving-udt-data.md

@@ -3,7 +3,7 @@ title: "Retrieving UDT Data"
 description: This article describes how to access UDTs in a SQL Server database.
 author: rwestMSFT
 ms.author: randolphwest
-ms.date: 12/27/2024
+ms.date: 03/19/2026
 ms.service: sql
 ms.subservice: clr
 ms.topic: "reference"
@@ -25,20 +25,26 @@ ms.custom: sfi-ropc-nochange
 
 [!INCLUDE [SQL Server](../../includes/applies-to-version/sqlserver.md)]
 
-In order to create a user-defined type (UDT) on the client, the assembly that was registered as a UDT in a [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] database must be available to the client application. The UDT assembly can be placed in the same directory with the application, or in the Global Assembly Cache (GAC). You can also set a reference to the assembly in your project.
+To create a user-defined type (UDT) on the client, the assembly registered as a UDT in a [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] database must be available to the client application. The UDT assembly can be placed in the same directory with the application, or in the Global Assembly Cache (GAC). You can also set a reference to the assembly in your project.
 
 ## Requirements for using UDTs in ADO.NET
 
-The assembly loaded in [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] and the assembly on the client must be compatible in order for the UDT to be created on the client. For UDTs defined with the `Native` serialization format, the assemblies must be structurally compatible. For assemblies defined with the `UserDefined` format, the assembly must be available on the client.
+The assembly loaded in [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] and the assembly on the client must be compatible for the UDT to be created on the client. For UDTs defined with the `Native` serialization format, the assemblies must be structurally compatible. For assemblies defined with the `UserDefined` format, the assembly must be available on the client.
 
-You don't need a copy of the UDT assembly on the client in order to retrieve the raw data from a UDT column in a table.
+You don't need a copy of the UDT assembly on the client to retrieve the raw data from a UDT column in a table.
 
 > [!NOTE]  
-> `SqlClient` might fail to load a UDT in the event of mismatched UDT versions or other problems. In this case, use regular troubleshooting mechanisms to determine why the assembly containing the UDT can't be found by the calling application. For more information, see [Diagnose Errors with Managed Debugging Assistants](/dotnet/framework/debug-trace-profile/diagnosing-errors-with-managed-debugging-assistants).
+> `SqlClient` might fail to load a UDT if UDT versions are mismatched or other problems occur. In this case, use regular troubleshooting mechanisms to determine why the assembly containing the UDT can't be found by the calling application. For more information, see [Diagnose Errors with Managed Debugging Assistants](/dotnet/framework/debug-trace-profile/diagnosing-errors-with-managed-debugging-assistants).
+
+The code examples in this article use `Microsoft.Data.SqlClient`, which is available as a NuGet package. To add this dependency to your project, run the following command:
+
+```dotnetcli
+dotnet add package Microsoft.Data.SqlClient
+```
 
 ## Access UDTs with a SqlDataReader
 
-A `System.Data.SqlClient.SqlDataReader` can be used from client code to retrieve a result set that contains a UDT column, which is exposed as an instance of the object.
+Use a `Microsoft.Data.SqlClient.SqlDataReader` from client code to retrieve a result set that contains a UDT column, which is exposed as an instance of the object.
 
 ### Example
 
@@ -50,11 +56,11 @@ This example shows how to use the `Main` method to create a new `SqlDataReader`
 
 1. The UDT defines a `Distance` method and a `GetDistanceFromXY` method.
 
-1. The sample code retrieves the values of the primary key and UDT columns in order to demonstrate the capabilities of the UDT.
+1. The sample code retrieves the values of the primary key and UDT columns to demonstrate the capabilities of the UDT.
 
 1. The sample code calls the `Point.Distance` and `Point.GetDistanceFromXY` methods.
 
-1. The results are displayed in the console window.
+1. The results display in the console window.
 
 > [!NOTE]  
 > The application must already have a reference to the UDT assembly.
@@ -63,8 +69,7 @@ This example shows how to use the `Main` method to create a new `SqlDataReader`
 
 ```csharp
 using System;
-using System.Data.Sql;
-using System.Data.SqlClient;
+using Microsoft.Data.SqlClient;
 
 namespace Microsoft.Samples.SqlServer
 {
@@ -118,8 +123,7 @@ Option Explicit On
 Option Strict On
 
 Imports System
-Imports System.Data.Sql
-Imports System.Data.SqlClient
+Imports Microsoft.Data.SqlClient
 
 Module ReadPoints
     Sub Main()
@@ -164,18 +168,17 @@ End Module
 
 ## Bind UDTs as bytes
 
-In some situations, you might want to retrieve the raw data from the UDT column. Perhaps the type isn't available locally, or you don't wish to instantiate an instance of the UDT. You can read the raw bytes into a byte array using the `GetBytes` method of a `SqlDataReader`. This method reads a stream of bytes from the specified column offset into the buffer of an array starting at a specified buffer offset. Another option is to use one of the `GetSqlBytes` or `GetSqlBinary` methods and read all of the contents in a single operation. In either case, the UDT object is never instantiated, so you don't need to set a reference to the UDT in the client assembly.
+In some situations, you might want to retrieve the raw data from the UDT column. Perhaps the type isn't available locally, or you don't want to instantiate an instance of the UDT. You can read the raw bytes into a byte array by using the `GetBytes` method of a `SqlDataReader`. This method reads a stream of bytes from the specified column offset into the buffer of an array starting at a specified buffer offset. Another option is to use one of the `GetSqlBytes` or `GetSqlBinary` methods and read all of the contents in a single operation. In either case, the UDT object is never instantiated, so you don't need to set a reference to the UDT in the client assembly.
 
 ### Example
 
-This example shows how to retrieve the `Point` data as raw bytes into a byte array using a `SqlDataReader`. The code uses a `System.Text.StringBuilder` to convert the raw bytes to a string representation to be displayed in the console window.
+This example shows how to retrieve the `Point` data as raw bytes into a byte array by using a `SqlDataReader`. The code uses a `System.Text.StringBuilder` to convert the raw bytes to a string representation to be displayed in the console window.
 
 ### [C#](#tab/csharp)
 
 ```csharp
 using System;
-using System.Data.Sql;
-using System.Data.SqlClient;
+using Microsoft.Data.SqlClient;
 using System.Data.SqlTypes;
 using System.Text;
 
@@ -228,8 +231,7 @@ Option Explicit On
 Option Strict On
 
 Imports System
-Imports System.Data.Sql
-Imports System.Data.SqlClient
+Imports Microsoft.Data.SqlClient
 Imports System.Data.SqlTypes
 Imports System.Text
 
@@ -281,14 +283,13 @@ End Module
 
 ### Example using GetSqlBytes
 
-This example shows how to retrieve the `Point` data as raw bytes in a single operation using the `GetSqlBytes` method. The code uses a `StringBuilder` to convert the raw bytes to a string representation to be displayed in the console window.
+This example shows how to retrieve the `Point` data as raw bytes in a single operation by using the `GetSqlBytes` method. The code uses a `StringBuilder` to convert the raw bytes to a string representation to be displayed in the console window.
 
 ### [C#](#tab/csharp)
 
 ```csharp
 using System;
-using System.Data.Sql;
-using System.Data.SqlClient;
+using Microsoft.Data.SqlClient;
 using System.Data.SqlTypes;
 using System.Text;
 
@@ -342,8 +343,7 @@ Option Explicit On
 Option Strict On
 
 Imports System
-Imports System.Data.Sql
-Imports System.Data.SqlClient
+Imports Microsoft.Data.SqlClient
 Imports System.Data.SqlTypes
 Imports System.Text
 
@@ -393,11 +393,11 @@ End Module
 
 ## Work with UDT parameters
 
-UDTs can be used as both input and output parameters in your ADO.NET code.
+You can use UDTs as both input and output parameters in your ADO.NET code.
 
 ## Use UDTs in query parameters
 
-UDTs can be used as parameter values when setting up a `SqlParameter` for a `System.Data.SqlClient.SqlCommand` object. The `SqlDbType.Udt` enumeration of a `SqlParameter` object is used to indicate that the parameter is a UDT when calling the `Add` method to the `Parameters` collection. The `UdtTypeName` property of a `SqlCommand` object is used to specify the fully qualified name of the UDT in the database using the `<database>.<schema_name>.<object_name>` syntax. You should use the fully qualified name to avoid ambiguity in your code.
+You can use UDTs as parameter values when you set up a `SqlParameter` for a `Microsoft.Data.SqlClient.SqlCommand` object. The `SqlDbType.Udt` enumeration of a `SqlParameter` object indicates that the parameter is a UDT when calling the `Add` method to the `Parameters` collection. The `UdtTypeName` property of a `SqlCommand` object specifies the fully qualified name of the UDT in the database by using the `<database>.<schema_name>.<object_name>` syntax. Use the fully qualified name to avoid ambiguity in your code.
 
 A local copy of the UDT assembly must be available to the client project.
 
@@ -410,8 +410,7 @@ The code in this example creates `SqlCommand` and `SqlParameter` objects to inse
 ```csharp
 using System;
 using System.Data;
-using System.Data.Sql;
-using System.Data.SqlClient;
+using Microsoft.Data.SqlClient;
 
 class Class1
 {
@@ -449,9 +448,8 @@ Option Explicit On
 Option Strict On
 
 Imports System
-Imports system.Data
-Imports System.Data.Sql
-Imports System.Data.SqlClient
+Imports System.Data
+Imports Microsoft.Data.SqlClient
 
 Module Module1
 

docs/relational-databases/clr-integration-database-objects-user-defined-types/accessing-user-defined-types-updating-udt-columns-with-dataadapters.md

@@ -1,9 +1,9 @@
 ---
 title: "Updating UDT Columns With DataAdapters"
-description: UDTs in a SQL Server database are supported by using System.Data.DataSet and System.Data.SqlClient.SqlDataAdapter to retrieve and modify data.
+description: UDTs in a SQL Server database are supported by using System.Data.DataSet and Microsoft.Data.SqlClient.SqlDataAdapter to retrieve and modify data.
 author: rwestMSFT
 ms.author: randolphwest
-ms.date: 12/27/2024
+ms.date: 03/19/2026
 ms.service: sql
 ms.subservice: clr
 ms.topic: "reference"
@@ -26,11 +26,17 @@ ms.custom: sfi-ropc-nochange
 
 [!INCLUDE [SQL Server](../../includes/applies-to-version/sqlserver.md)]
 
-User-defined types (UDTs) are supported by using a `System.Data.DataSet` and a `System.Data.SqlClient.SqlDataAdapter` to retrieve and modify data.
+You can retrieve and modify user-defined types (UDTs) by using a `System.Data.DataSet` and a `Microsoft.Data.SqlClient.SqlDataAdapter`.
+
+The code examples in this article use `Microsoft.Data.SqlClient`, which is available as a NuGet package. To add this dependency to your project, run the following command:
+
+```dotnetcli
+dotnet add package Microsoft.Data.SqlClient
+```
 
 ## Populate a dataset
 
-You can use a [!INCLUDE [tsql](../../includes/tsql-md.md)] `SELECT` statement to select UDT column values to populate a dataset using a data adapter. The following example assumes that you have a `Points` table defined with the following structure and some sample data. The following [!INCLUDE [tsql](../../includes/tsql-md.md)] statements create the `Points` table and insert a few rows.
+Use a [!INCLUDE [tsql](../../includes/tsql-md.md)] `SELECT` statement to select UDT column values to populate a dataset by using a data adapter. The following example assumes that you have a `Points` table defined with the following structure and some sample data. The following [!INCLUDE [tsql](../../includes/tsql-md.md)] statements create the `Points` table and insert a few rows.
 
 ```sql
 CREATE TABLE dbo.Points
@@ -81,7 +87,7 @@ You can use two methods to update a UDT column in a `DataSet`:
 
 - Provide custom `InsertCommand`, `UpdateCommand`, and `DeleteCommand` objects for a `SqlDataAdapter` object.
 
-- Use the command builder (`System.Data.SqlClient.SqlCommandBuilder`) to create automatically the `INSERT`, `UPDATE`, and `DELETE` commands for you. In order to have conflict detection, add a **timestamp** column (alias **rowversion**) to the [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] table that contains the UDT. The **timestamp** data type allows you to version-stamp the rows in a table, and is guaranteed to be unique within a database. When a value in the table is changed, [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] automatically updates the 8-byte binary number for the row affected by the change.
+- Use the command builder (`Microsoft.Data.SqlClient.SqlCommandBuilder`) to create automatically the `INSERT`, `UPDATE`, and `DELETE` commands for you. To enable conflict detection, add a **timestamp** column (alias **rowversion**) to the [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] table that contains the UDT. The **timestamp** data type allows you to version-stamp the rows in a table, and is guaranteed to be unique within a database. When a value in the table is changed, [!INCLUDE [ssNoVersion](../../includes/ssnoversion-md.md)] automatically updates the 8-byte binary number for the row affected by the change.
 
 The `SqlCommandBuilder` doesn't consider the UDT for conflict detection unless there's a **timestamp** column in the underlying table. UDTs might or might not be comparable, so they aren't included in the `WHERE` clause when the "compare original values" option is used to generate a command.
 
@@ -112,7 +118,7 @@ VALUES (4, CONVERT (Point, '4,6'));
 
 The following ADO.NET example has two methods:
 
-- `UserProvidedCommands`, which demonstrates how to supply `InsertCommand`, `UpdateCommand`, and `DeleteCommand` objects for updating the `Point` UDT in the `Points` table (which doesn't contain a **timestamp** column).
+- `UserProvidedCommands`, which demonstrates how to supply `InsertCommand`, `UpdateCommand`, and `DeleteCommand` objects for updating the `Point` UDT in the `Points` table (without a **timestamp** column).
 
 - `CommandBuilder`, which demonstrates how to use a `SqlCommandBuilder` in the `Points_ts` table that contains the **timestamp** column.
 
@@ -121,7 +127,7 @@ The following ADO.NET example has two methods:
 ```csharp
 using System;
 using System.Data;
-using System.Data.SqlClient;
+using Microsoft.Data.SqlClient;
 
 class Class1
 {
@@ -268,7 +274,7 @@ class Class1
 ```vb
 Imports System
 Imports System.Data
-Imports System.Data.SqlClient
+Imports Microsoft.Data.SqlClient
 
 Module Module1
     ' Retrieves the connection string