All versions of Visual Studio up until Visual Studio 2008 generated a type-safe data table that derived from the DataTable class, without a type-safe way of enumerating over the table or converting it to an array:

[Serializable]
public partial class ContactsDataTable : DataTable,IEnumerable
{...}

To streamline the task of converting a data table to an array, you can use my DataTableHelper class, defined as:

public static class DataTableHelper
{
   public static T[] ToArray<R,T>(this DataTable table,Func<R,T> converter)
                                                              where R : DataRow;
}

DataTableHelper defines the DataTable extension method ToArray( ).

All DataTableHelper requires is a converter from a data row in the table to the data contract. DataTableHelper also adds some compile-time and runtime type-safety verification. Example 3-11 demonstrates using DataTableHelper.

[DataContract]
struct Contact
{
   [DataMember]
   public string FirstName;

   [DataMember]
   public string LastName;
}
[ServiceContract]
interface IContactManager
{
   [OperationContract]
   Contact[] GetContacts(  );
   ...
}
class ContactManager : IContactManager
{
   public Contact[] GetContacts(  )
   {
      ContactsTableAdapter adapter = new ContactsTableAdapter(  );
      MyDataSet.ContactsDataTable contactsTable = adapter.GetData(  );

      Func<MyDataSet.ContactsRow,Contact> converter = (row)=>
                                                      {
                                                          return new Contact(  )
                                                                     {
                                                       FirstName = row.FirstName,
                                                       LastName = row.LastName
                                                                     };
                                                      };
      return contactsTable.ToArray(converter);
   }
   //Rest of the implementation
}

In Example 3-11, the GetContacts( ) method uses the type-safe table adapter ContactsTableAdapter (listed in Example 3-10) to get the records from the database in the form of the type-safe table MyDataSet.ContactsDataTable. GetContacts( ) then defines a lambda expression that converts an instance of the type-safe data row MyDataSet.ContactsRow to a Contact instance. Finally, GetContacts( ) calls the ToArray( ) extension, providing it with the table and the converter.

Example 3-12 shows the implementation of DataTableHelper.ToArray( ).

public static class DataTableHelper
{
   public static T[] ToArray<R,T>(this DataTable table,Func<R,T> converter)
                                                                 where R : DataRow
   {
      //Verify [DataContract] or [Serializable] on T
      Debug.Assert(IsDataContract(typeof(T)) || typeof(T).IsSerializable);

      if(table.Rows.Count == 0)
      {
         return new T[]{};
      }

      //Verify table contains correct rows
      Debug.Assert(MatchingTableRow<R>(table));

      return table.Rows.Cast<R>().Select(converter).ToArray();
   }
   static bool IsDataContract(Type type)
   {
      object[] attributes =
                     type.GetCustomAttributes(typeof(DataContractAttribute),false);
      return attributes.Length == 1;
   }
   static bool MatchingTableRow<R>(DataTable table)
   {
      if(table.Rows.Count == 0)
      {
         return true;
      }
      return table.Rows[0] is R;
   }
}

DataTableHelper.ToArray() first uses the Cast() LINQ extension method to convert each row (which is an object) into an R, then it uses a Select() query to convert that collection of rows to a collection of Ts, and finally converts that collection into an array.

DataTableHelper adds some type safety. At compile time, it constrains the type parameter R to be a data row. At runtime, DataTableHelper verifies that the type parameter T is decorated either with the DataContract attribute or the Serializable attribute. Verifying the presence of the DataContract attribute is done via the helper method IsDataContract(), which uses reflection to look up the attribute. Verifying the Serializable attribute is done by checking whether the IsSerializable bit is set on the type. The method returns an empty array if the table is empty. Finally, ToArray() verifies that the provided table has the rows specified with the type parameter R. This is done via the MatchingTableRow() helper method, which gets the first row and verifies its type.

Visual Studio 2008 introduced support for strongly typed queries and LINQ. When using Visual Studio 2008 to generate a table, the table derives from TypedTableBase<T>:

[Serializable]
public partial class ContactsDataTable : TypedTableBase<ContactsRow>
{...}

This makes it easier to use LINQ to convert the table directly into an array. Using the same definitions as Example 3-11, you can now write:

public Contact[] GetContacts(  )
{
   Func<CustomersDataSet.ContactsRow,Contact> converter = (row)=>
                                                          {
                                                             return new Contact(  )
                                                                        {
                                                        FirstName = row.FirstName,
                                                        LastName = row.LastName
                                                                        };
                                                          };
   return contactsTable.Select(converter).ToArray(  );
}

Or even:

public Contact[] GetContacts(  )
{
   return contactsTable.Select(row => new Contact(  ){
                    FirstName = row.FirstName,LastName = row.LastName}).ToArray(  );
}