Bagikan melalui


Cara: Menerapkan CopyToDataTable<T> Di mana Tipe Generik T Bukan DataRow

Objek DataTable sering digunakan untuk pengikatan data. Metode CopyToDataTable mengambil hasil kueri dan menyalin data ke dalam DataTable, yang kemudian dapat digunakan untuk pengikatan data. Metode CopyToDataTable, bagaimanapun, hanya beroperasi pada sumber IEnumerable<T> di mana parameter generik T berjenis DataRow. Meskipun ini berguna, ini tidak memungkinkan tabel dibuat dari urutan jenis skalar, dari kueri yang memproyeksikan jenis anonim, atau dari kueri yang melakukan gabungan tabel.

Topik ini menjelaskan cara menerapkan dua metode ekstensi kustom CopyToDataTable<T> yang menerima parameter generik T dari jenis selain DataRow. Logika untuk membuat DataTable dari sumber IEnumerable<T> terkandung dalam kelas ObjectShredder<T>, yang kemudian dibungkus dalam dua metode ekstensi CopyToDataTable<T> yang kelebihan beban. Metode Shred dari kelas ObjectShredder<T> mengembalikan DataTable yang diisi dan menerima tiga parameter input: sumber IEnumerable<T>, DataTable, dan enumerasi LoadOption. Skema awal yang dikembalikan DataTable didasarkan pada skema jenis T. Jika tabel yang ada disediakan sebagai input, skema harus konsisten dengan skema jenis T. Setiap properti publik dan bidang jenis T dikonversi ke DataColumn dalam tabel yang dikembalikan. Jika urutan sumber berisi jenis yang berasal dari T, skema tabel yang dikembalikan diperluas untuk properti atau bidang publik tambahan.

Untuk contoh penggunaan metode kustom CopyToDataTable<T>, lihat Membuat DataTable Dari Kueri.

Untuk mengimplementasikan metode CopyToDataTable<T> kustom di aplikasi Anda

  1. Terapkan kelas ObjectShredder<T> untuk membuat DataTable dari sumber IEnumerable<T>:

    public class ObjectShredder<T>
    {
        readonly FieldInfo[] _fi;
        readonly PropertyInfo[] _pi;
        readonly Dictionary<string, int> _ordinalMap;
        readonly Type _type;
    
        // ObjectShredder constructor.
        public ObjectShredder()
        {
            _type = typeof(T);
            _fi = _type.GetFields();
            _pi = _type.GetProperties();
            _ordinalMap = new Dictionary<string, int>();
        }
    
        /// <summary>
        /// Loads a DataTable from a sequence of objects.
        /// </summary>
        /// <param name="source">The sequence of objects to load into the DataTable.</param>
        /// <param name="table">The input table. The schema of the table must match that
        /// the type T.  If the table is null, a new table is created with a schema
        /// created from the public properties and fields of the type T.</param>
        /// <param name="options">Specifies how values from the source sequence will be applied to
        /// existing rows in the table.</param>
        /// <returns>A DataTable created from the source sequence.</returns>
        public DataTable Shred(IEnumerable<T> source, DataTable table, LoadOption? options)
        {
            // Load the table from the scalar sequence if T is a primitive type.
            if (typeof(T).IsPrimitive)
            {
                return ShredPrimitive(source, table, options);
            }
    
            // Create a new table if the input table is null.
            table ??= new DataTable(typeof(T).Name);
    
            // Initialize the ordinal map and extend the table schema based on type T.
            table = ExtendTable(table, typeof(T));
    
            // Enumerate the source sequence and load the object values into rows.
            table.BeginLoadData();
            foreach (T item in source)
            {
                if (options != null)
                {
                    table.LoadDataRow(ShredObject(table, item), (LoadOption)options);
                }
                else
                {
                    table.LoadDataRow(ShredObject(table, item), true);
                }
            }
            table.EndLoadData();
    
            // Return the table.
            return table;
        }
    
        public DataTable ShredPrimitive(IEnumerable<T> source, DataTable table, LoadOption? options)
        {
            // Create a new table if the input table is null.
            table ??= new DataTable(typeof(T).Name);
    
            if (!table.Columns.Contains("Value"))
            {
                table.Columns.Add("Value", typeof(T));
            }
    
            // Enumerate the source sequence and load the scalar values into rows.
            table.BeginLoadData();
            using (IEnumerator<T> e = source.GetEnumerator())
            {
                var values = new object[table.Columns.Count];
                while (e.MoveNext())
                {
                    values[table.Columns["Value"].Ordinal] = e.Current;
    
                    if (options != null)
                    {
                        table.LoadDataRow(values, (LoadOption)options);
                    }
                    else
                    {
                        table.LoadDataRow(values, true);
                    }
                }
            }
            table.EndLoadData();
    
            // Return the table.
            return table;
        }
    
        public object[] ShredObject(DataTable table, T instance)
        {
            FieldInfo[] fi = _fi;
            PropertyInfo[] pi = _pi;
    
            if (instance.GetType() != typeof(T))
            {
                // If the instance is derived from T, extend the table schema
                // and get the properties and fields.
                ExtendTable(table, instance.GetType());
                fi = instance.GetType().GetFields();
                pi = instance.GetType().GetProperties();
            }
    
            // Add the property and field values of the instance to an array.
            var values = new object[table.Columns.Count];
            foreach (FieldInfo f in fi)
            {
                values[_ordinalMap[f.Name]] = f.GetValue(instance);
            }
    
            foreach (PropertyInfo p in pi)
            {
                values[_ordinalMap[p.Name]] = p.GetValue(instance, null);
            }
    
            // Return the property and field values of the instance.
            return values;
        }
    
        public DataTable ExtendTable(DataTable table, Type type)
        {
            // Extend the table schema if the input table was null or if the value
            // in the sequence is derived from type T.
            foreach (FieldInfo f in type.GetFields())
            {
                if (!_ordinalMap.ContainsKey(f.Name))
                {
                    // Add the field as a column in the table if it doesn't exist
                    // already.
                    DataColumn dc = table.Columns.Contains(f.Name) ? table.Columns[f.Name]
                        : table.Columns.Add(f.Name, f.FieldType);
    
                    // Add the field to the ordinal map.
                    _ordinalMap.Add(f.Name, dc.Ordinal);
                }
            }
            foreach (PropertyInfo p in type.GetProperties())
            {
                if (!_ordinalMap.ContainsKey(p.Name))
                {
                    // Add the property as a column in the table if it doesn't exist
                    // already.
                    DataColumn dc = table.Columns.Contains(p.Name) ? table.Columns[p.Name]
                        : table.Columns.Add(p.Name, p.PropertyType);
    
                    // Add the property to the ordinal map.
                    _ordinalMap.Add(p.Name, dc.Ordinal);
                }
            }
    
            // Return the table.
            return table;
        }
    }
    
    Public Class ObjectShredder(Of T)
        ' Fields
        Private _fi As FieldInfo()
        Private _ordinalMap As Dictionary(Of String, Integer)
        Private _pi As PropertyInfo()
        Private _type As Type
    
        ' Constructor 
        Public Sub New()
            Me._type = GetType(T)
            Me._fi = Me._type.GetFields
            Me._pi = Me._type.GetProperties
            Me._ordinalMap = New Dictionary(Of String, Integer)
        End Sub
    
        Public Function ShredObject(ByVal table As DataTable, ByVal instance As T) As Object()
            Dim fi As FieldInfo() = Me._fi
            Dim pi As PropertyInfo() = Me._pi
            If (Not instance.GetType Is GetType(T)) Then
                ' If the instance is derived from T, extend the table schema
                ' and get the properties and fields.
                Me.ExtendTable(table, instance.GetType)
                fi = instance.GetType.GetFields
                pi = instance.GetType.GetProperties
            End If
    
            ' Add the property and field values of the instance to an array.
            Dim values As Object() = New Object(table.Columns.Count - 1) {}
            Dim f As FieldInfo
            For Each f In fi
                values(Me._ordinalMap.Item(f.Name)) = f.GetValue(instance)
            Next
            Dim p As PropertyInfo
            For Each p In pi
                values(Me._ordinalMap.Item(p.Name)) = p.GetValue(instance, Nothing)
            Next
    
            ' Return the property and field values of the instance.
            Return values
        End Function
    
    
        ' Summary:           Loads a DataTable from a sequence of objects.
        ' source parameter:  The sequence of objects to load into the DataTable.</param>
        ' table parameter:   The input table. The schema of the table must match that 
        '                    the type T.  If the table is null, a new table is created  
        '                    with a schema created from the public properties and fields 
        '                    of the type T.
        ' options parameter: Specifies how values from the source sequence will be applied to 
        '                    existing rows in the table.
        ' Returns:           A DataTable created from the source sequence.
    
        Public Function Shred(ByVal source As IEnumerable(Of T), ByVal table As DataTable, ByVal options As LoadOption?) As DataTable
    
            ' Load the table from the scalar sequence if T is a primitive type.
            If GetType(T).IsPrimitive Then
                Return Me.ShredPrimitive(source, table, options)
            End If
    
            ' Create a new table if the input table is null.
            If (table Is Nothing) Then
                table = New DataTable(GetType(T).Name)
            End If
    
            ' Initialize the ordinal map and extend the table schema based on type T.
            table = Me.ExtendTable(table, GetType(T))
    
            ' Enumerate the source sequence and load the object values into rows.
            table.BeginLoadData()
            Using e As IEnumerator(Of T) = source.GetEnumerator
                Do While e.MoveNext
                    If options.HasValue Then
                        table.LoadDataRow(Me.ShredObject(table, e.Current), options.Value)
                    Else
                        table.LoadDataRow(Me.ShredObject(table, e.Current), True)
                    End If
                Loop
            End Using
            table.EndLoadData()
    
            ' Return the table.
            Return table
        End Function
    
    
        Public Function ShredPrimitive(ByVal source As IEnumerable(Of T), ByVal table As DataTable, ByVal options As LoadOption?) As DataTable
            ' Create a new table if the input table is null.
            If (table Is Nothing) Then
                table = New DataTable(GetType(T).Name)
            End If
            If Not table.Columns.Contains("Value") Then
                table.Columns.Add("Value", GetType(T))
            End If
    
            ' Enumerate the source sequence and load the scalar values into rows.
            table.BeginLoadData()
            Using e As IEnumerator(Of T) = source.GetEnumerator
                Dim values As Object() = New Object(table.Columns.Count - 1) {}
                Do While e.MoveNext
                    values(table.Columns.Item("Value").Ordinal) = e.Current
                    If options.HasValue Then
                        table.LoadDataRow(values, options.Value)
                    Else
                        table.LoadDataRow(values, True)
                    End If
                Loop
            End Using
            table.EndLoadData()
    
            ' Return the table.
            Return table
        End Function
    
        Public Function ExtendTable(ByVal table As DataTable, ByVal type As Type) As DataTable
            ' Extend the table schema if the input table was null or if the value 
            ' in the sequence is derived from type T.
            Dim f As FieldInfo
            Dim p As PropertyInfo
    
            For Each f In type.GetFields
                If Not Me._ordinalMap.ContainsKey(f.Name) Then
                    Dim dc As DataColumn
    
                    ' Add the field as a column in the table if it doesn't exist
                    ' already.
                    dc = IIf(table.Columns.Contains(f.Name), table.Columns.Item(f.Name), table.Columns.Add(f.Name, f.FieldType))
    
                    ' Add the field to the ordinal map.
                    Me._ordinalMap.Add(f.Name, dc.Ordinal)
                End If
    
            Next
    
            For Each p In type.GetProperties
                If Not Me._ordinalMap.ContainsKey(p.Name) Then
                    ' Add the property as a column in the table if it doesn't exist
                    ' already.
                    Dim dc As DataColumn
                    dc = IIf(table.Columns.Contains(p.Name), table.Columns.Item(p.Name), table.Columns.Add(p.Name, p.PropertyType))
    
                    ' Add the property to the ordinal map.
                    Me._ordinalMap.Add(p.Name, dc.Ordinal)
                End If
            Next
    
            ' Return the table.
            Return table
        End Function
    
    End Class
    

    Contoh sebelumnya mengasumsikan bahwa properti dan bidang dari jenis DataColumn merupakan nilai yang tidak dapat diubah ke null. Untuk menangani properti dan bidang dengan jenis nilai yang dapat diubah ke null, gunakan kode berikut:

    // Nullable-aware code for properties.
    DataColumn dc = table.Columns.Contains(p.Name) ? table.Columns[p.Name] : table.Columns.Add(p.Name, Nullable.GetUnderlyingType(p.PropertyType) ?? p.PropertyType);
    
    // Nullable-aware code for fields.
    DataColumn dc = table.Columns.Contains(f.Name) ? table.Columns[f.Name] : table.Columns.Add(f.Name, Nullable.GetUnderlyingType(f.FieldType) ?? f.FieldType);
    
  2. Terapkan metode ekstensi kustom CopyToDataTable<T> di kelas :

    public static class CustomLINQtoDataSetMethods
    {
        public static DataTable CopyToDataTable<T>(this IEnumerable<T> source) =>
            new ObjectShredder<T>().Shred(source, null, null);
    
        public static DataTable CopyToDataTable<T>(this IEnumerable<T> source,
                                                    DataTable table, LoadOption? options) =>
            new ObjectShredder<T>().Shred(source, table, options);
    }
    
    Public Module CustomLINQtoDataSetMethods
        <Extension()> _
        Public Function CopyToDataTable(Of T)(ByVal source As IEnumerable(Of T)) As DataTable
            Return New ObjectShredder(Of T)().Shred(source, Nothing, Nothing)
        End Function
    
        <Extension()> _
        Public Function CopyToDataTable(Of T)(ByVal source As IEnumerable(Of T), ByVal table As DataTable, ByVal options As LoadOption?) As DataTable
            Return New ObjectShredder(Of T)().Shred(source, table, options)
        End Function
    
    End Module
    
  3. Tambahkan kelas ObjectShredder<T> dan metode ekstensi CopyToDataTable<T> ke aplikasi Anda.

Module Module1
    Sub Main()
        ' Your application code using CopyToDataTable<T>.
    End Sub
End Module

Public Module CustomLINQtoDataSetMethods
…
End Module

Public Class ObjectShredder(Of T)
…
End Class
class Program
{
    static void Main(string[] args)
    {
        // Your application code using CopyToDataTable<T>.
    }
}
public static class CustomLINQtoDataSetMethods
{
…
}
public class ObjectShredder<T>
{
…
}

Lihat juga