Microsoft Learn

Typed Datasets in ADO.NET

Typed datasets offer a powerful and type-safe way to work with data in ADO.NET. Unlike untyped datasets, where data access relies on string names and indices, typed datasets are generated from an XML Schema Definition (XSD) file. This generation process creates strongly-typed classes that mirror the structure of your data, providing IntelliSense support, compile-time checking, and improved performance.

What is a Typed Dataset?

A typed dataset is essentially a custom class that inherits from the base System.Data.DataSet class. It is created by a designer (like Visual Studio's dataset designer) based on an XSD schema. This schema defines the tables, columns, relationships, and constraints within your dataset.

When you create a typed dataset, the following are generated:

• A custom DataSet class with the name you specify.
• Strongly-typed DataTable classes for each table defined in the schema.
• Strongly-typed DataColumn objects within each DataTable.
• Strongly-typed DataRow classes for each table, with properties for each column.
• Strongly-typed DataRelation objects.

Benefits of Using Typed Datasets

• Type Safety: Accessing data using properties instead of strings eliminates common runtime errors like typos in column names.
• IntelliSense: Developers get rich code completion suggestions directly in the IDE, improving productivity.
• Compile-Time Checking: Errors related to data access are caught during compilation rather than at runtime.
• Improved Performance: Strongly-typed access can be more efficient than dynamic access.
• Readability: Code becomes more self-explanatory.

Creating a Typed Dataset

In Visual Studio, the most common way to create a typed dataset is:

1. Add a new item to your project.
2. Select "Dataset" from the templates.
3. Name your dataset (e.g., MyData.xsd).
4. The dataset designer will open. You can then drag tables from Server Explorer or define your schema manually.
5. Once the XSD is created, Visual Studio automatically generates the typed dataset code. You can find this code in a separate file (often named MyData.Designer.cs) which you should not edit directly.

Working with a Typed Dataset

Once generated, you can instantiate and use your typed dataset like any other object.

Example: Populating and Accessing Data

Assume you have a typed dataset named CustomersDataset with a table named Customers, which has columns like CustomerID (integer) and CustomerName (string).

// Instantiate the typed dataset
CustomersDataset customersDs = new CustomersDataset();

// Access a typed DataTable
CustomersDataset.CustomersDataTable customersTable = customersDs.Customers;

// Add a new row (using the strongly-typed row object)
CustomersDataset.CustomersRow newRow = customersTable.NewCustomersRow();
newRow.CustomerID = 101;
newRow.CustomerName = "Acme Corporation";
customersTable.AddCustomersRow(newRow);

// Populate from a data adapter (assuming it's configured to fill customersTable)
// SqlDataAdapter adapter = new SqlDataAdapter("SELECT CustomerID, CustomerName FROM Customers", connection);
// adapter.Fill(customersDs.Customers);

// Iterate through the rows using typed properties
foreach (CustomersDataset.CustomersRow row in customersDs.Customers)
{
    Console.WriteLine($"ID: {row.CustomerID}, Name: {row.CustomerName}");
    // You can also check for nulls using IsColumnNull() methods
    if (!row.IsCustomerNameNull())
    {
        Console.WriteLine($"Customer Name: {row.CustomerName}");
    }
}

// Accessing a specific value
if (customersDs.Customers.Count > 0)
{
    CustomersDataset.CustomersRow firstCustomer = customersDs.Customers[0];
    string name = firstCustomer.CustomerName;
}
            

Handling Null Values

Typed datasets provide methods like IsColumnNameNull() to check if a particular column's value is DBNull. This helps prevent NullReferenceException errors.

if (!currentRow.IsCustomerIDNull())
{
    int id = currentRow.CustomerID;
}
            

Typed vs. Untyped Datasets

While typed datasets offer many advantages, untyped datasets can be more flexible in scenarios where the data structure is dynamic or unknown at compile time. However, for most applications with a well-defined data model, typed datasets are the preferred choice for their robustness and developer productivity benefits.

Summary

Typed datasets in ADO.NET provide a significant advantage for data access by leveraging compile-time type checking and IntelliSense. By defining your data schema using XSD, you can generate strongly-typed classes that make your code cleaner, safer, and easier to maintain.