public static T GetEntity<T>(DataRow dr)
{
	bool columnCanNotCorrespond = true;
	return GetEntity<T>(dr, columnCanNotCorrespond);
}
/// <summary>
/// Riempie una Entità con i valori presenti in un DataRow automaticamente. 
/// Se un valore è NULLO inserirà il valore di default.
/// L'automatismo funzione solo se i nomi delle colonne (campi dal Db\DataRow) corrispondono ai nomi 
/// delle properties; se una Property non ha colonna del DataRow semplicemente è valorizzata al Default
/// (come dopo una istanzizione dell'oggetto mediante "new"). Se una colonna esiste ma non c'è la 
/// corrispondente proprietà la segnalazione dell'eccezione dipenderà dal flag: columnCanNotCorrespond
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="dr"></param>
/// <param name="columnCanNotCorrespond">Se true, non scatta eccezione se c'è una colonna che non 
/// è corrispondente ad una Property</param>
/// <returns></returns>
public static T GetEntity<T>(DataRow dr, bool columnCanNotCorrespond)
{
	Type entityType = typeof(T);
	T entity = (T)entityType.Assembly.CreateInstance(entityType.FullName);
	string columnName = string.Empty;
	string strErrorMsg = string.Empty;
 
	try
	{
		if (columnCanNotCorrespond)
		{
			foreach (DataColumn dc in dr.Table.Columns)
			{
				columnName = dc.ColumnName;
				object columnValue = dr[columnName];
				//La Property Esiste?
				if (entity.GetType().GetProperty(columnName
												, BindingFlags.Public
													| BindingFlags.Instance
													| BindingFlags.IgnoreCase) != null)
				{
					//Assegnazione condizionata affinchè rimanga il valore di Default nel caso il valore da inserire sia nullo 
					if (columnValue != DBNull.Value)
					{
						PropertyInfo prop = entity.GetType().GetProperty(columnName
												 , BindingFlags.Public
													| BindingFlags.Instance
													| BindingFlags.IgnoreCase);
						if (prop.PropertyType.ToString() == "System.Boolean")
						{
							prop.SetValue(entity, bool.Parse(columnValue.ToString()), null);
						}
						else if (prop.PropertyType.ToString() == "System.DateTime")
						{
							prop.SetValue(entity, DateTime.Parse(columnValue.ToString()), null);
						}
						else if (prop.PropertyType.ToString() == "System.Int32")
						{
							prop.SetValue(entity, Int32.Parse(columnValue.ToString()), null);
						}
						//CUSTOM types, enum?
						else if (prop.PropertyType.ToString().Contains("Enum"))
						{
							//ToDo
						}
						else //Standard Type
						{
							prop.SetValue(entity, columnValue, null);
						}
					}
				}
			}
		}
		else //Scatterà eccezione se la Property non corrisponde alla colonna!
		{
			foreach (DataColumn dc in dr.Table.Columns)
			{
				columnName = dc.ColumnName;
				object columnValue = dr[columnName];
				//Assegnazione condizionata affinchè rimanga il valore di Default nel caso il valore da inserire sia nullo 
				if (columnValue != DBNull.Value)
				{
					entity.GetType().GetProperty(columnName
												 , BindingFlags.Public
													| BindingFlags.Instance
													| BindingFlags.IgnoreCase).SetValue(entity, columnValue, null);
				}
			}
		}
	}
	catch (Exception ex)
	{
		strErrorMsg = string.Format("Method GetEntity<T>, column '{0}'\r\n{1}", columnName, ex.Message);
		throw new Exception(strErrorMsg);
	}
	return (T)entity;
}

private static Dictionary<string, PropertyInfo[]> _entitiesFields = new Dictionary<string, PropertyInfo[]>();
 
        /// <summary>
        /// Data una DataRow, restituisce un'entità
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="Entity"></param>
        /// <returns></returns>
        private static T FromDataRowToEntity<T>(DataRow dr) where T : new()
        {
            T result = new T();
 
            if (result != null && dr != null)
            {
                string fullyName = typeof(T).FullName;
                lock (_entitiesFields)
                {
                    if (!_entitiesFields.ContainsKey(fullyName))
                    {
                        // Ottengo tutti i campi della entity
                        _entitiesFields.Add(fullyName, result.GetType().GetProperties());
                    }
                }
 
                PropertyInfo[] properties = _entitiesFields[fullyName];
 
                if (properties != null)
                {
                    for (int i = 0; i < properties.Length; i++)
                    {
                        #region per ogni campo dell'entità, cerco il valore nella riga e glielo assegno
                        PropertyInfo property = properties[i];
                        string propertyName = property.Name;
                        if (dr.Table.Columns.Contains(propertyName))
                            property.SetValue(result, GetFieldValue(property, dr[propertyName]), null);
                        #endregion
                    }
                }
            }
            return result;
        }
 
        /// <summary>
        /// Data una DataTable, restituisce una collezione di entità
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        private static List<T> FromDataTableToListOfEntity<T>(DataTable dt) where T : new()
        {
            List<T> tmp_list = new List<T>();
            if (dt != null)
            {
                foreach (DataRow dr in dt.Rows)
                {
                    T toAdd = FromDataRowToEntity<T>(dr);
                    if (toAdd != null) tmp_list.Add(toAdd);
                }
            }
 
            return tmp_list;
        }

/// <summary>
/// Converts a Generic List into a DataTable.
/// </summary>
/// <param name="genericList">Generic list</param>
/// <returns>DataTable object</returns>
public static DataTable GenericListToDataTable(object genericList)
{
	DataTable dataTable = null;
	Type listType = genericList.GetType();
 
	if (listType.IsGenericType & (genericList != null))
	{
		//determine the underlying type the List<> contains
		Type elementType = listType.GetGenericArguments()[0];
 
		//create empty table -- give it a name in case
		//it needs to be serialized
		dataTable = new DataTable(elementType.Name + "List");
 
		//define the table -- add a column for each public
		//property or field
		MemberInfo[] memberInfos = elementType.GetMembers(BindingFlags.Public | BindingFlags.Instance);
		foreach (MemberInfo memberInfo in memberInfos)
		{
			if (memberInfo.MemberType == MemberTypes.Property)
			{
				PropertyInfo propertyInfo = memberInfo as PropertyInfo;
				if (IsNullableType(propertyInfo.PropertyType))
				{
					dataTable.Columns.Add(propertyInfo.Name, new NullableConverter(propertyInfo.PropertyType).UnderlyingType);
				}
				else
				{
					dataTable.Columns.Add(propertyInfo.Name, propertyInfo.PropertyType);
				}
			}
			else if (memberInfo.MemberType == MemberTypes.Field)
			{
				FieldInfo fieldInfo = memberInfo as FieldInfo;
				dataTable.Columns.Add(fieldInfo.Name, fieldInfo.FieldType);
			}
		}
 
		//populate the table
		IList listData = genericList as IList;
		foreach (object record in listData)
		{
			int index = 0;
			object[] fieldValues = new object[dataTable.Columns.Count];
			foreach (DataColumn columnData in dataTable.Columns)
			{
				MemberInfo memberInfo = elementType.GetMember(columnData.ColumnName)[0];
				if (memberInfo.MemberType == MemberTypes.Property)
				{
					PropertyInfo propertyInfo = memberInfo as PropertyInfo;
					fieldValues[index] = propertyInfo.GetValue(record, null);
				}
				else if (memberInfo.MemberType == MemberTypes.Field)
				{
					FieldInfo fieldInfo = memberInfo as FieldInfo;
					fieldValues[index] = fieldInfo.GetValue(record);
				}
				index += 1;
			}
			dataTable.Rows.Add(fieldValues);
		}
	}
	return dataTable;
}
 
/// <summary>
/// Check if a type is Nullable type
/// </summary>
/// <param name="propertyType">Type to be checked</param>
/// <returns>true/false</returns>
/// <remarks></remarks>
private static bool IsNullableType(Type propertyType)
{
	return (propertyType.IsGenericType) && (object.ReferenceEquals(propertyType.GetGenericTypeDefinition(), typeof(Nullable<>)));
}

private static T MapCustom<T>(object entitySource)
{
	Type entityDestType = typeof(T);
	Type entitySourceType = entitySource.GetType();
	T entityDestination = (T)entityDestType.Assembly.CreateInstance(entityDestType.FullName);
 
	foreach (PropertyInfo piSrc in entitySourceType.GetProperties(BindingFlags.FlattenHierarchy // Mamber static and public, nested type are not returned
																))
	{
		if (piSrc.CanRead)
		{
			foreach (PropertyInfo piDst in entityDestType.GetProperties(BindingFlags.FlattenHierarchy // Nested type are not returned
																		))
			{
				if (piSrc.Name.Equals(piDst.Name, StringComparison.InvariantCultureIgnoreCase))
				{
					if (piSrc.PropertyType == piDst.PropertyType)
					{
						if (piDst.CanWrite)
						{
							// value
							object srcVal = piSrc.GetValue(entitySource, null);
							piDst.SetValue(entityDestination, srcVal, null);
						}
					}
					else
					{
						// Managing nullable values ....
					}
				}
			}
		}
	}
	return (T)entityDestination;
}

private T MapCustom<T>(object entitySource)
{
	Type entityDestType = typeof(T);
	Type entitySourceType = entitySource.GetType();
	T entityDestination = (T)entityDestType.Assembly.CreateInstance(entityDestType.FullName);
	string srcPropertyName = string.Empty;
	string csvNotMatchingPropertiesName = string.Empty; // Not used BUT may be logged for debug purpose!
 
	try
	{
		// Arrray of member static and public, nested type are not returned:
		PropertyInfo[] arrPropertyInfoDest = entityDestType.GetProperties() //BindingFlags.FlattenHierarchy
															.Where(pd => pd.CanWrite).ToArray();
 
		// For each member static and public, nested type are not returned:
		foreach (PropertyInfo piSrc in entitySourceType.GetProperties() //BindingFlags.FlattenHierarchy
															.Where(ps => ps.CanRead))
		{
			srcPropertyName = piSrc.Name;
			PropertyInfo piDst = arrPropertyInfoDest.SingleOrDefault(i => i.Name.Equals(piSrc.Name,
																			   StringComparison.InvariantCultureIgnoreCase)
																		   && i.PropertyType == piSrc.PropertyType);
			if (piDst != null)
			{
				// Set value:
				object srcVal = piSrc.GetValue(entitySource, null);
				piDst.SetValue(entityDestination, srcVal, null);
			}
			else
			{
				csvNotMatchingPropertiesName += string.Format("{0},", srcPropertyName);
			}
		}
	}
	catch (Exception ex)
	{
		priceListManager.Error(string.Format("Error on source property '{0}'.\r\n{1}", 
											srcPropertyName, ex.Message), 
								ex);
		// ToDo Manage exception!
	}
	return (T)entityDestination;
}