/// <summary>
/// Convierte la primer fila DataRow dentro del System.Data.DataTable a un Objeto del tipo <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">Tipo referencia para serializar.</typeparam>
/// <param name="dataTable">El contenido a convertir.</param>
/// <returns>Regresa un objeto ya convertido al tipo <typeparamref name="T"/>.</returns>
public static T ConvertDataTableToObjectOfType <T>(System.Data.DataTable dataTable) where T : new()
{
T newObject = new T();
if (dataTable.Rows.Count > 0)
{
PropertyInfo[] properties = typeof(T).GetProperties();
Dictionary <string, HeaderName> headers = GetCustomAttributesFromPropertiesInClass <HeaderName, T>();
foreach (DataColumn column in dataTable.Columns)
{
foreach (PropertyInfo property in properties)
{
if (property.CanWrite)
{
if (headers.TryGetValue(property.Name, out HeaderName header))
{
if (header.Name.Equals(column.ColumnName))
{
property.SetValue(newObject, SimpleConverter.ConvertStringToType(dataTable.Rows[0][header.Name].ToString(), property.PropertyType));
break;
}
}
else if (column.ColumnName.Equals(property.Name))
{
property.SetValue(newObject, SimpleConverter.ConvertStringToType(dataTable.Rows[0][property.Name].ToString(), property.PropertyType));
break;
}
}
}
}
}
return(newObject);
}
private static void SetValueInProperty <T>(Dictionary <string, string> columns, PropertyInfo property, HeaderName headerNameAttribute, string header, T newObj)
{
if (!property.CanWrite)
{
return;
}
if (columns.ContainsKey(header))
{
property.SetValue(newObj, SimpleConverter.ConvertStringToType(columns[header], property.PropertyType));
}
else
{
if (headerNameAttribute == null)
{
throw new Exception(string.Format("No se encontro algun dato para el encabezado {0} en el archivo proporcionado.", header));
}
else
{
if (headerNameAttribute.Important)
{
throw new Exception(string.Format("No se encontro algun dato para el encabezado {0} en el archivo proporcionado.", header));
}
}
}
}
/// <summary>
/// Asigna los valores proporcionados en las propiedades correspondientes a la instancia del objeto de tipo <typeparamref name="T"/>. Solo se aceptan valores originados desde un objeto anonimo o predefinidos del mismo tipo enviado.
/// </summary>
/// <typeparam name="T">El tipo del objeto a asignar.</typeparam>
/// <param name="obj">El objeto a alimentarle los valores proporcionados.</param>
/// <param name="values">Los valores usados en la asignacion de las propiedades. Se admiten objetos anonimos o predefinidos del mismo tipo enviado.</param>
/// <returns>Regresa el objeto ya alimentado de los valores.</returns>
public static T SetValuesIntoObjectOfType <T>(T obj, dynamic values)
{
PropertyInfo[] typeProperties = typeof(T).GetProperties();
PropertyInfo[] anonymousProperties = values.GetType().GetProperties();
foreach (PropertyInfo typeProperty in typeProperties)
{
foreach (PropertyInfo anonymousProperty in anonymousProperties)
{
if (typeProperty.Name.Equals(anonymousProperty.Name))
{
if (typeProperty.CanWrite)
{
typeProperty.SetValue(obj, SimpleConverter.ConvertStringToType(anonymousProperty.GetValue(values).ToString(), typeProperty.PropertyType));
}
else
{
throw new SetAccessorNotFoundException(typeProperty.Name);
}
break;
}
}
}
return(obj);
}
internal static T ConvertReaderToObjectOfType <T>(IDataReader reader, IEnumerable <PropertyInfo> properties) where T : Cope <T>, IManageable, new()
{
T newObj = new T();
foreach (PropertyInfo property in properties)
{
property.SetValue(newObj, SimpleConverter.ConvertStringToType(reader[property.Name].ToString(), property.PropertyType));
}
return(newObj);
}
/// <summary>
/// Convierte un objeto de tipo System.Data.DataTable a un HashSet del tipo <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">Tipo referencia para serializar.</typeparam>
/// <param name="dataTable">El contenido a convertir.</param>
/// <returns>Regresa un nuevo HashSet del tipo <typeparamref name="T"/> ya con los objetos incorporados.</returns>
public static HashSet <T> ConvertDataTableToHashSetOfType <T>(System.Data.DataTable dataTable) where T : new()
{
HashSet <T> newSet = new HashSet <T>();
foreach (DataRow row in dataTable.Rows)
{
PropertyInfo[] properties = typeof(T).GetProperties();
T newObject = new T();
foreach (PropertyInfo property in properties)
{
if (dataTable.Columns.Contains(property.Name) && property.CanWrite)
{
property.SetValue(newObject, SimpleConverter.ConvertStringToType(row[property.Name].ToString(), property.PropertyType));
}
}
newSet.Add(newObject);
}
return(newSet);
}
public static ICollection <object> ConvertDataTableToListOfType(System.Data.DataTable dataTable, Type target)
{
ICollection <object> newList = new List <object>();
foreach (DataRow row in dataTable.Rows)
{
PropertyInfo[] properties = target.GetProperties();
object newObject = Activator.CreateInstance(target);
foreach (PropertyInfo property in properties)
{
if (dataTable.Columns.Contains(property.Name) && property.CanWrite)
{
property.SetValue(newObject, SimpleConverter.ConvertStringToType(row[property.Name].ToString(), property.PropertyType));
}
}
newList.Add(newObject);
}
return(newList);
}
/// <summary>
/// Convierte un objeto de tipo System.Data.DataTable a un Diccionario con el tipo de la llave <typeparamref name="TKey"/> y valor <typeparamref name="TValue"/>.
/// </summary>
/// <typeparam name="TKey">El tipo que se usara como Llave.</typeparam>
/// <typeparam name="TValue">El tipo que se usara como Valor.</typeparam>
/// <param name="dataTable">El contenido a convertir.</param>
/// <param name="keyName">El nombre de la columna dentro del objeto System.Data.DataTable.Columns que se usara como Llave.</param>
/// <param name="valueName">El nombre de la columna dentro del objeto System.Data.DataTable.Columns que se usara como Valor.</param>
/// <returns>Regresa un nuevo Diccionario alimentado con los valores proporcionados.</returns>
public static Dictionary <TKey, TValue> ConvertDataTableToDictionary <TKey, TValue>(System.Data.DataTable dataTable, string keyName, string valueName)
{
if (dataTable.Columns.Count < 2)
{
throw new ArgumentException("Esta funcion requiere 2 columnas en el objeto System.Data.DataTable.");
}
Dictionary <TKey, TValue> newDictionary = new Dictionary <TKey, TValue>();
TKey key;
TValue value;
for (int i = 0; i < dataTable.Rows.Count; i++)
{
key = (TKey)SimpleConverter.ConvertStringToType(dataTable.Rows[i][keyName].ToString(), typeof(TKey));
value = (TValue)SimpleConverter.ConvertStringToType(dataTable.Rows[i][valueName].ToString(), typeof(TValue));
newDictionary.Add(key, value);
}
return(newDictionary);
}
/// <summary>
/// Convierte un objeto de tipo System.Data.DataTable a un Diccionario con el tipo de la llave <typeparamref name="TKey"/> y el objeto como valor.
/// </summary>
/// <typeparam name="TKey">El tipo que se usara como llave.</typeparam>
/// <typeparam name="T">El tipo que se usara como objeto para el valor del diccionario.</typeparam>
/// <param name="dataTable">El contenido a convertir.</param>
/// <param name="keyName">El nombre de la columna dentro del objeto System.Data.DataTable.Columns que se usara como Llave.</param>
/// <returns>Regresa un nuevo Diccionario alimentado con los valores proporcionados.</returns>
public static Dictionary <TKey, T> ConvertDataTableToDictionary <TKey, T>(System.Data.DataTable dataTable, string keyName) where T : new()
{
Dictionary <TKey, T> newDictionary = new Dictionary <TKey, T>();
foreach (DataRow row in dataTable.Rows)
{
T newObject = new T();
PropertyInfo[] properties = typeof(T).GetProperties();
TKey key = (TKey)SimpleConverter.ConvertStringToType(row[keyName].ToString(), typeof(TKey));
foreach (PropertyInfo property in properties)
{
if (dataTable.Columns.Contains(property.Name) && property.CanWrite)
{
property.SetValue(newObject, SimpleConverter.ConvertStringToType(row[property.Name].ToString(), property.PropertyType));
}
}
newDictionary.Add(key, newObject);
}
return(newDictionary);
}
public static Hashtable ConvertDataTableToHashtableOfType <T>(System.Data.DataTable dataTable) where T : Cope <T>, IManageable, new()
{
Hashtable newHashTable = new Hashtable();
if (dataTable != null)
{
foreach (DataRow row in dataTable.Rows)
{
PropertyInfo[] properties = typeof(T).GetProperties();
T newObject = new T();
foreach (PropertyInfo property in properties)
{
if (dataTable.Columns.Contains(property.Name) && property.CanWrite)
{
property.SetValue(newObject, SimpleConverter.ConvertStringToType(row[property.Name].ToString(), property.PropertyType));
}
}
newHashTable.Add(Cope <T> .ModelComposition.PrimaryKeyProperty.GetValue(newObject), newObject);
}
}
return(newHashTable);
}