Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés

Cómo implementar CopyToDataTable<T> donde el tipo genérico T no es un objeto DataRow

 

El objeto DataTable se suele utilizar para el enlace de datos. El método CopyToDataTable toma los resultados de una consulta y copia los datos en un objeto DataTable que puede utilizarse después para el enlace de datos. Sin embargo, los métodos CopyToDataTable solo funcionan en un origen IEnumerable<T> en el que el parámetro genérico T es de tipo DataRow. Aunque esto es útil, no permite la creación de tablas a partir de una secuencia de tipos escalares, a partir de consultas que proyectan tipos anónimos, o a partir de consultas que realizan combinaciones de tablas.

En este tema se describe cómo se implementan dos métodos de extensión CopyToDataTable<T> personalizados que aceptan un parámetro genérico T de un tipo distinto de DataRow. La lógica para crear un objeto DataTable desde un origen IEnumerable<T> está contenida en la clase ObjectShredder<T>, que se incluye después en dos métodos de extensión CopyToDataTable<T> sobrecargados. El método Shred de la clase ObjectShredder<T> devuelve el objeto DataTable relleno y acepta tres parámetros de entrada: un origen IEnumerable<T>, un objeto DataTable y una enumeración LoadOption. El esquema inicial del objeto DataTable devuelto está basado en el esquema del tipo T. Si se proporciona una tabla existente como entrada, el esquema debe ser coherente con el esquema del tipo T. Cada propiedad y campo públicos del tipo T se convierten a un objeto DataColumn en la tabla devuelta. Si la secuencia de origen contiene un tipo derivado de T, el esquema de la tabla devuelta se expande para las propiedades o campos públicos adicionales.

Para obtener ejemplos sobre el uso de los métodos CopyToDataTable<T> personalizados, vea Crear DataTable desde una consulta (LINQ to DataSet).

Para implementar los métodos CopyToDataTable<T> personalizados en la aplicación

  1. Implemente la clase ObjectShredder<T> para crear un objeto DataTable desde un origen IEnumerable<T>:

    public class ObjectShredder<T>
    {
        private System.Reflection.FieldInfo[] _fi;
        private System.Reflection.PropertyInfo[] _pi;
        private System.Collections.Generic.Dictionary<string, int> _ordinalMap;
        private System.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.
            if (table == 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();
            using (IEnumerator<T> e = source.GetEnumerator())
            {
                while (e.MoveNext())
                {
                    if (options != null)
                    {
                        table.LoadDataRow(ShredObject(table, e.Current), (LoadOption)options);
                    }
                    else
                    {
                        table.LoadDataRow(ShredObject(table, e.Current), 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.
            if (table == 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())
            {
                Object[] 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.
            Object[] 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;
        }
    }
    
  2. Implemente los métodos de extensión CopyToDataTable<T> personalizados en una clase:

    public static class CustomLINQtoDataSetMethods
    {
        public static DataTable CopyToDataTable<T>(this IEnumerable<T> source)
        {
            return new ObjectShredder<T>().Shred(source, null, null);
        }
    
        public static DataTable CopyToDataTable<T>(this IEnumerable<T> source,
                                                    DataTable table, LoadOption? options)
        {
            return new ObjectShredder<T>().Shred(source, table, options);
        }
    
    }
    
  3. Agregue la clase ObjectShredder<T> y los métodos de extensión CopyToDataTable<T> a la aplicación.

    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
    
  4. class Program
    {
            static void Main(string[] args)
            {
               // Your application code using CopyToDataTable<T>.
            }
    }
    public static class CustomLINQtoDataSetMethods
    {
    …
    }
    public class ObjectShredder<T>
    {
    …
    }
    
Mostrar: