Creating a Strongly Typed DataSet
Problem
You want to create a strongly typed object wrapper around a DataSet .
Solution
Use one of the three techniques shown in the discussion to create a strongly typed DataSet using either the Visual Studio .NET IDE or a command line approach.
Discussion
A strongly typed DataSet is a collection of classes that inherit from and extend the DataSet , DataTable , and DataRow classes, and provide additional properties, methods , and events based on the DataSet schema. You can use all of the functionality in classes from which the strongly typed classes inherit in the same way as with untyped classes.
A strongly typed DataSet class contains, in addition to a single class extending the DataSet class, three classes for each table in the DataSet extending each of the DataTable , DataRow , and DataRowChangeEvent classes. This recipe describes these classes and discusses their commonly used methods and properties.
There is a class named TableName DataTable for each table in the strongly typed DataSet . It has the base class DataTable . Table 2-1 lists commonly used methods of this class specific to the strongly typed DataSet .
Table 2-1. TableNameDataTable methods
|
Method |
Description |
|---|---|
|
Add TableName Row( ) |
Adds a row to the table. The method has two overloads: one takes a TableName Row object as the argument, while the other takes a set of arguments containing the column values. |
|
FindBy PrimaryKeyField1 ... PrimaryKeyFieldN ( ) |
Takes N arguments which are the values of the primary key fields of the row to find. Returns a TableName Row object, if found. |
|
New TableName Row( ) |
Takes no arguments and returns a new TableName Row object with the same schema as the table to be used for adding new rows to the table in the strongly typed DataSet . |
There is a class named TableName Row for each table in the strongly typed DataSet . It has the base class DataRow and represents a row of data in the table. Table 2-2 lists commonly used properties and methods of this class specific to the strongly typed DataSet .
Table 2-2. TableNameRow class properties and methods
|
Property/method |
Description |
|---|---|
|
Typed Accessor |
Sets and get the value of a column. The typed accessor is exposed as a property having the same name as the underlying data column. |
|
Is ColumnName Null( ) |
Returns a Boolean value indicating whether the field contains a null value. |
|
Set ColumnName Null( ) |
Sets the value of the underlying field to a null value. |
|
Get ChildTableName Rows( ) |
Returns the rows for the table as an array of ChildTableName Row objects. |
|
ParentTableName Row( ) |
Returns the parent row as an object of type ParentTableName Row . |
There is a class named TableNameRow ChangeEvent for each table in the strongly typed DataSet . It has the base class EventArgs . Table 2-3 describes the properties of this class.
Table 2-3. TableNameRowChangeEvent properties
|
Property |
Description |
|---|---|
|
Action |
A value from the System.Data.DataRowAction enumeration that describes the action performed on a row that caused the event to be raised. |
|
Row |
The TableName Row object for which the event was raised. |
A strongly typed DataSet has some advantages over using an untyped DataSet :
- The schema information is contained within the strongly typed DataSet resulting in a performance over retrieving schema information at runtime. The schema of an untyped DataSet can also be defined programmatically, as discussed in Recipe 2.1, resulting in similar performance.
- Programming is more intuitive and code is easier to maintain. Table, column, and other object names are accessed through properties having names based on the underlying data source object names rather than by using index or delimited string arguments. The Visual Studio .NET IDE provides autocomplete functionality for strongly typed DataSet names.
- Type mismatch errors and errors resulting from misspelled or out of bounds arguments used with DataSet objects can be detected during compilation, rather than at runtime.
The disadvantages of a strongly typed DataSet object include:
- Additional overhead when executing. If strongly typed functionality is not required, performance is better with an untyped DataSet rather than with a typed DataSet .
- A strongly typed DataSet must be regenerated when the structure of the underlying data source changes. Applications using these strongly typed DataSet objects will need to be rebuilt with a reference to the new strongly typed DataSet . With an untyped DataSet , as long as the new schema is a superset of the old schema, existing clients can simply ignore any new data and do not need to be recompiled.
Four ways to generate a typed DataSet class are described in the following subsections.
Using the Visual Studio .NET IDE to generate a typed DataSet
The first and easiest method uses Visual Studio .NET following these steps:
- Drop a DataAdapter object from the Data tab in the Visual Studio .NET Toolbox onto a design surface such as a form or a component. The Data Adapter Configuration Wizard will appear.
- Press Next to continue to the Choose Your Data Connection dialog.
- Select an existing connection or create a new one as required. Press Next to continue to the Choose a Query Type dialog.
- Select the Use SQL statements radio button and press Next to continue to the Generate the SQL Statements dialog.
- Press the Advanced Options... button.
- Uncheck all three check boxes on the Advanced SQL Generation Options dialog and press OK.
- Press the Query Builder... button.
- Select only one table on the Add Table dialog and press Add. Press Close.
- Check the columns from the table to include or (All Columns ) and press OK.
- Press Next to continue to the View Wizard Results dialog.
- Press Finish to complete the wizard.
- Repeat steps 1-11 for the other tables that you want to have included in the strongly typed DataSet.
- Right-click on the design surface and select Generate DataSet.
- Provide a name for the strongly typed DataSet, select the tables to be included, and press OK to generate the new strongly typed DataSet.
- To relate tables in the new strongly typed DataSet, open the XSD file for the new DataSet in the Solution Explorer window.
- Right-click on the child table in XSD schema designer, select Add
New Relation . . . from the shortcut menu, and complete the dialog. Repeat this step to create all required relationships. - Instances of the strongly typed DataSet can now be created programmatically either by using the new keyword in C# or the New keyword in Visual Basic .NET or by dragging the DataSet object from the Data tab in the Visual Studio .NET Toolbox onto a design surface such as a component or form.
Using the TypedDataSetGenerator class to generate a typed DataSet
The second technique is to derive a class from the TypedDataSetGenerator class. The static Generate( ) method of the TypedDataSetGenerator class is used to create a strongly typed DataSet . The prototype of the method is:
public static void Generate(DataSet dataSet, CodeNamespace codeNamespace, ICodeGenerator codeGenerator);
The arguments of the method are:
DataSet
The DataSet used to specify the schema for the typed DataSet .
codeNamespace
The target namespace for the typed DataSet .
codeGenerator
A class capable of dynamically rendering source code in a specific language and used to create the typed DataSet .
Using an XSD schema file to generate a typed DataSet
The other two methods require an XSD schema file. You can generate this file in a number of ways: using the Visual Studio .NET tools, third-party tools, or the DataSet WriteXmlSchema( ) method. You can create a strongly typed DataSet from the XSD schema file using Visual Studio .NET or using the XML Schema Definition Tool.
To create a strongly typed DataSet from the XSD schema using Visual Studio .NET, follow these steps:
- Right-click on the project in the Solution Explorer window, choose Add/Existing Item... from the shortcut menu, and select the XSD file to add it to the project.
- Select the XSD schema file from the Solution Explorer window and open it in the designer window.
- Right-click on the designer window and select Generate DataSet.
- Instances of the strongly typed DataSet can now be created programmatically by using the new keyword in C# or the New keyword in Visual Basic .NET or by dragging the DataSet object from the Data tab in the Visual Studio .NET Toolbox onto a design surface such as a component or form.
The second way to create a strongly typed DataSet from an XSD schema is to use the XML Schema Definition Tool ( XSD.EXE ) found in the .NET Framework SDK bin directory. Follow these steps:
Generate the strongly typed DataSet class file from the XSD schema file by issuing the following command from the command prompt:
xsd mySchemaFile.xsd /d /l:CS
The /d switch specifies that source code for a strongly typed DataSet should be created.
The /l:CS switch specifies that the utility should use the C# language, which is the default if not specified. For VB.NET, use the switch /l:VB .
The XML Schema Definition Tool offers other options. For more information, see the .NET Framework SDK documentation or the MSDN Library.
The class file that is generated for the strongly typed DataSet is named using the DataSet name in the XSD schema and has an extension corresponding to the programming language: .cs for C# and .vb for VB.NET. The strongly typed DataSet class can now be added to a project.
|