using Microsoft.CSharp;
using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;

namespace AIMSExtension
{
	public static class GPFunData
	{
		public static bool IsNumericType(this object o)
		{
			TypeCode typeCode = Type.GetTypeCode(o.GetType());
			TypeCode typeCode2 = typeCode;
			return typeCode2 - TypeCode.SByte <= 10;
		}

		public static List<T> ToList<T>(this DataTable dataTable) where T : new()
		{
			return GPFunData.DataTableToList<T>(dataTable);
		}

		public static DataTable MergeColumn(DataTable dataTable, string colName)
		{
			bool flag = dataTable.Rows.Count <= 1;
			DataTable result;
			if (flag)
			{
				result = dataTable;
			}
			else
			{
				DataTable dataTable2 = new DataTable();
				int columnIndex = 0;
				List<string> list = new List<string>();
				Dictionary<int, int> dictionary = new Dictionary<int, int>();
				DataColumnCollection columns = dataTable.Columns;
				int count = columns.Count;
				int num = 0;
				DataColumn column;
				for (int i = 0; i < count; i++)
				{
					string columnName = columns[i].ColumnName;
					bool flag2 = !colName.Equals(columnName);
					if (flag2)
					{
						list.Add(columnName);
						column = new DataColumn(columnName, columns[i].DataType);
						dataTable2.Columns.Add(column);
						dictionary.Add(i, num);
						num++;
					}
					else
					{
						columnIndex = i;
					}
				}
				column = new DataColumn(colName, Type.GetType("System.String"));
				dataTable2.Columns.Add(column);
				DataRow[] array = dataTable.Select("", string.Join(",", list));
				int num2 = array.Length;
				DataRow dataRow = dataTable2.NewRow();
				list.Clear();
				int[] cols = dictionary.Keys.ToArray<int>();
				for (int j = 0; j < num2; j++)
				{
					int num3 = j - 1;
					bool flag3 = num3 < 0;
					bool flag4 = flag3 || !GPFunData.IsSameDataRow(array[num3], array[j], cols);
					bool flag5 = flag4;
					if (flag5)
					{
						bool flag6 = num3 >= 0;
						if (flag6)
						{
							dataRow[count - 1] = string.Join(" \r\n", list);
						}
						list.Clear();
						list.Add(array[j][columnIndex].ToString());
						dataRow = dataTable2.NewRow();
						GPFunData.CopyDataRow(array[j], dataRow, dictionary);
						dataTable2.Rows.Add(dataRow);
					}
					else
					{
						list.Add(array[j][columnIndex].ToString());
					}
				}
				result = dataTable2;
			}
			return result;
		}

		public static bool IsSameDataRow(DataRow dr1, DataRow dr2, int[] cols)
		{
			bool result = true;
			for (int i = 0; i < cols.Length; i++)
			{
				int columnIndex = cols[i];
				bool flag = !dr1[columnIndex].ToString().Equals(dr2[columnIndex].ToString());
				if (flag)
				{
					result = false;
					break;
				}
			}
			return result;
		}

		public static bool IsSameDataRow(DataRow dr1, DataRow dr2, Dictionary<int, int> cols)
		{
			bool result = true;
			foreach (KeyValuePair<int, int> current in cols)
			{
				bool flag = dr1[current.Key].ToString() != dr2[current.Value].ToString();
				if (flag)
				{
					result = false;
					break;
				}
			}
			return result;
		}

		public static bool IsSameDataRow(DataRow dr1, DataRow dr2, string[] cols)
		{
			bool result = true;
			for (int i = 0; i < cols.Length; i++)
			{
				string columnName = cols[i];
				bool flag = dr1[columnName].ToString() != dr2[columnName].ToString();
				if (flag)
				{
					result = false;
					break;
				}
			}
			return result;
		}

		public static bool IsSameDataRow(DataRowView dr1, DataRowView dr2, string[] cols)
		{
			bool result = true;
			for (int i = 0; i < cols.Length; i++)
			{
				string property = cols[i];
				bool flag = dr1[property].ToString() != dr2[property].ToString();
				if (flag)
				{
					result = false;
					break;
				}
			}
			return result;
		}

		public static bool CopyDataRow(DataRow dr1, DataRow dr2)
		{
			DataColumnCollection columns = dr1.Table.Columns;
			Dictionary<string, int> dictionary = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			int i = 0;
			int count = columns.Count;
			while (i < count)
			{
				dictionary.Add(columns[i].ColumnName, i);
				i++;
			}
			columns = dr2.Table.Columns;
			int j = 0;
			int count2 = columns.Count;
			while (j < count2)
			{
				string columnName = columns[j].ColumnName;
				bool flag = dictionary.ContainsKey(columnName);
				if (flag)
				{
					dr2[j] = dr1[dictionary[columnName]];
				}
				j++;
			}
			return true;
		}

		public static bool CopyDataRow(DataRow dr1, DataRow dr2, int[] cols)
		{
			bool flag = cols.Length == 0;
			if (flag)
			{
				int i = 0;
				int num = dr2.ItemArray.Length;
				while (i < num)
				{
					dr2[i] = dr1[i];
					i++;
				}
			}
			else
			{
				for (int j = 0; j < cols.Length; j++)
				{
					int columnIndex = cols[j];
					dr2[columnIndex] = dr1[columnIndex];
				}
			}
			return true;
		}

		public static bool CopyDataRow(DataRow dr1, DataRow dr2, Dictionary<int, int> cols)
		{
			foreach (KeyValuePair<int, int> current in cols)
			{
				dr2[current.Value] = dr1[current.Key];
			}
			return true;
		}

		public static bool CopyDataRow(DataRow dr1, DataRow dr2, string[] colNames)
		{
			bool flag = colNames == null || colNames.Length == 0;
			bool result;
			if (flag)
			{
				result = GPFunData.CopyDataRow(dr1, dr2);
			}
			else
			{
				for (int i = 0; i < colNames.Length; i++)
				{
					string columnName = colNames[i];
					dr2[columnName] = dr1[columnName];
				}
				result = true;
			}
			return result;
		}

		public static int DeleteEmptyFieldRows(DataTable dataTable, string fieldName)
		{
			int num = 0;
			DataRowCollection rows = dataTable.Rows;
			int count = rows.Count;
			for (int i = count - 1; i >= 0; i--)
			{
				DataRow dataRow = rows[i];
				bool flag = dataRow.RowState == DataRowState.Deleted;
				if (!flag)
				{
					object obj = dataRow[fieldName];
					bool flag2 = obj == DBNull.Value || GPFunctions.CStr<object>(obj) == "";
					if (flag2)
					{
						dataRow.Delete();
						num++;
					}
				}
			}
			return num;
		}

		public static int DeleteEmptyFieldsRows(DataTable dataTable, string[] fieldNames)
		{
			int num = 0;
			DataRowCollection rows = dataTable.Rows;
			int count = rows.Count;
			for (int i = count - 1; i >= 0; i--)
			{
				DataRow dataRow = rows[i];
				bool flag = dataRow.RowState == DataRowState.Deleted;
				if (!flag)
				{
					bool flag2 = false;
					for (int j = 0; j < fieldNames.Length; j++)
					{
						string columnName = fieldNames[j];
						object obj = dataRow[columnName];
						bool flag3 = obj == DBNull.Value || GPFunctions.CStr<object>(obj) == "";
						if (flag3)
						{
							flag2 = true;
							num++;
							break;
						}
					}
					bool flag4 = flag2;
					if (flag4)
					{
						dataRow.Delete();
					}
				}
			}
			return num;
		}

		public static List<T> DataTableToList<T>(DataTable dataTable) where T : new()
		{
			T t = Activator.CreateInstance<T>();
			Type type = t.GetType();
			List<T> list = new List<T>();
			DataColumnCollection columns = dataTable.Columns;
			Dictionary<string, IndexType> dictionary = new Dictionary<string, IndexType>();
			PropertyInfo[] properties = type.GetProperties();
			for (int i = 0; i < properties.Length; i++)
			{
				PropertyInfo propertyInfo = properties[i];
				string name = propertyInfo.Name;
				int num = columns.IndexOf(name);
				bool flag = num >= 0;
				if (flag)
				{
					IndexType indexType;
					indexType.index = num;
					bool flag2 = !propertyInfo.PropertyType.Equals(columns[num].DataType);
					if (flag2)
					{
						indexType.type = 1;
					}
					else
					{
						indexType.type = 0;
					}
					dictionary.Add(name, indexType);
				}
			}
			foreach (DataRow dataRow in dataTable.Rows)
			{
				t = Activator.CreateInstance<T>();
				foreach (string current in dictionary.Keys)
				{
					PropertyInfo property = type.GetProperty(current);
					bool flag3 = property == null;
					if (!flag3)
					{
						IndexType indexType = dictionary[current];
						int index = indexType.index;
						bool flag4 = dataRow[index] != DBNull.Value;
						if (flag4)
						{
							bool flag5 = indexType.type == 0;
							if (flag5)
							{
								property.SetValue(t, dataRow[index], null);
							}
							else
							{
								Type type2 = property.PropertyType;
								bool flag6 = type2.IsGenericType && type2.GetGenericTypeDefinition() == typeof(Nullable<>);
								if (flag6)
								{
									type2 = type2.GetGenericArguments()[0];
								}
								object value = Convert.ChangeType(dataRow[index], type2);
								property.SetValue(t, value, null);
							}
						}
					}
				}
				list.Add(t);
			}
			return list;
		}

		public static DataTable ToListDataTable<T>(DataTable dataTable) where T : new()
		{
			T t = Activator.CreateInstance<T>();
			Type type = t.GetType();
			DataColumnCollection columns = dataTable.Columns;
			Dictionary<int, Type> dictionary = new Dictionary<int, Type>();
			PropertyInfo[] properties = type.GetProperties();
			for (int i = 0; i < properties.Length; i++)
			{
				PropertyInfo propertyInfo = properties[i];
				string name = propertyInfo.Name;
				int num = columns.IndexOf(name);
				bool flag = num >= 0;
				if (flag)
				{
					bool flag2 = !propertyInfo.PropertyType.Equals(columns[num].DataType);
					if (flag2)
					{
						dictionary.Add(num, propertyInfo.PropertyType);
					}
				}
			}
			foreach (KeyValuePair<int, Type> current in dictionary)
			{
				columns[current.Key].DataType = current.Value;
			}
			dataTable.AcceptChanges();
			return dataTable;
		}

		public static DataTable ToListDataTable2<T>(DataTable dataTable) where T : new()
		{
			T t = Activator.CreateInstance<T>();
			Type type = t.GetType();
			DataColumnCollection columns = dataTable.Columns;
			Dictionary<string, IndexType> dictionary = new Dictionary<string, IndexType>();
			PropertyInfo[] properties = type.GetProperties();
			for (int i = 0; i < properties.Length; i++)
			{
				PropertyInfo propertyInfo = properties[i];
				string name = propertyInfo.Name;
				int num = columns.IndexOf(name);
				bool flag = num >= 0;
				if (flag)
				{
					bool flag2 = !propertyInfo.PropertyType.Equals(columns[num].DataType);
					if (flag2)
					{
						columns.Add(string.Format("new__{1}", name), propertyInfo.PropertyType);
						IndexType indexType;
						indexType.index = num;
						indexType.type = columns.Count - 1;
						dictionary.Add(name, indexType);
					}
				}
			}
			foreach (DataRow dataRow in dataTable.Rows)
			{
				foreach (string current in dictionary.Keys)
				{
					IndexType indexType = dictionary[current];
					int index = indexType.index;
					int type2 = indexType.type;
					bool flag3 = dataRow[index] != DBNull.Value;
					if (flag3)
					{
						dataRow[type2] = Convert.ChangeType(dataRow[index], columns[type2].DataType);
					}
				}
			}
			foreach (string current2 in dictionary.Keys)
			{
				int index2 = columns.IndexOf(current2);
				columns.RemoveAt(index2);
				string name2 = string.Format("new__{0}", current2);
				columns[name2].ColumnName = current2;
			}
			dataTable.AcceptChanges();
			return dataTable;
		}

		public static List<string> GetDataTableModifiedFirtRowInfo(DataTable dataTable)
		{
			List<string> list = new List<string>();
			DataColumnCollection columns = dataTable.Columns;
			int count = columns.Count;
			foreach (DataRow dataRow in dataTable.Rows)
			{
				bool flag = false;
				bool flag2 = dataRow.RowState == DataRowState.Modified;
				if (flag2)
				{
					for (int i = 0; i < count; i++)
					{
						bool flag3 = dataRow[i, DataRowVersion.Original] == DBNull.Value;
						if (flag3)
						{
							bool flag4 = dataRow[i] != DBNull.Value;
							if (flag4)
							{
								flag = true;
								list.Add(string.Format("Row={0}, FieldName={1}, DataType={2}, VALUE={3}, ORIGINAL=DBNull.Value", new object[]
								{
									i,
									columns[i].ColumnName,
									columns[i].DataType.Name,
									dataRow[i].ToString()
								}));
							}
						}
						else
						{
							bool flag5 = dataRow[i] == DBNull.Value;
							if (flag5)
							{
								flag = true;
								list.Add(string.Format("Row={0}, FieldName={1}, DataType={2}, VALUE=DBNull.Value, ORIGINAL={3}", new object[]
								{
									i,
									columns[i].ColumnName,
									columns[i].DataType.Name,
									dataRow[i, DataRowVersion.Original].ToString()
								}));
							}
							else
							{
								string text = dataRow[i].ToString();
								string text2 = dataRow[i, DataRowVersion.Original].ToString();
								bool flag6 = text != text2;
								if (flag6)
								{
									flag = true;
									list.Add(string.Format("Row={0}, FieldName={1}, DataType={2}, VALUE={3}, ORIGINAL={4}", new object[]
									{
										i,
										columns[i].ColumnName,
										columns[i].DataType.Name,
										text,
										text2
									}));
								}
							}
						}
					}
				}
				bool flag7 = flag;
				if (flag7)
				{
					break;
				}
			}
			return list;
		}

		public static bool IsDataRowChanged(DataRow dataRow)
		{
			DataRowState rowState = dataRow.RowState;
			bool flag = rowState == DataRowState.Added || rowState == DataRowState.Deleted;
			bool result;
			if (flag)
			{
				result = true;
			}
			else
			{
				bool flag2 = rowState != DataRowState.Modified;
				if (flag2)
				{
					result = false;
				}
				else
				{
					DataColumnCollection columns = dataRow.Table.Columns;
					int count = columns.Count;
					bool flag3 = false;
					for (int i = 0; i < count; i++)
					{
						bool flag4 = dataRow[i, DataRowVersion.Original] == DBNull.Value;
						if (flag4)
						{
							bool flag5 = dataRow[i] != DBNull.Value;
							if (flag5)
							{
								flag3 = true;
								break;
							}
						}
						else
						{
							bool flag6 = dataRow[i] == DBNull.Value;
							if (flag6)
							{
								flag3 = true;
								break;
							}
							bool flag7 = dataRow[i].ToString() != dataRow[i, DataRowVersion.Original].ToString();
							if (flag7)
							{
								flag3 = true;
								break;
							}
						}
					}
					result = flag3;
				}
			}
			return result;
		}

		public static DataTable DataTableColumnLandscape(DataTable dt, string[] columns, string landscapeColumn, string valueColumn)
		{
			DataColumnCollection columns2 = dt.Columns;
			int num = columns2.IndexOf(landscapeColumn);
			bool flag = num < 0;
			if (flag)
			{
				throw new Exception(string.Format("字段名{0}不存在。", landscapeColumn));
			}
			int num2 = columns2.IndexOf(valueColumn);
			bool flag2 = num2 < 0;
			if (flag2)
			{
				throw new Exception(string.Format("字段名{0}不存在。", valueColumn));
			}
			int[] array = null;
			bool flag3 = columns != null;
			if (flag3)
			{
				int num3 = columns.Length;
				bool flag4 = num3 > 0;
				if (flag4)
				{
					array = new int[num3];
					for (int i = 0; i < num3; i++)
					{
						int num4 = columns2.IndexOf(columns[i]);
						bool flag5 = num4 < 0;
						if (flag5)
						{
							throw new Exception(string.Format("字段名{0}不存在。", columns[i]));
						}
						array[i] = num4;
					}
				}
			}
			return GPFunData.DataTableColumnLandscape(dt, array, num, num2);
		}

		public static DataTable DataTableColumnLandscape(DataTable dt, int[] commonColumns, int landscapeColumn, int valueColumn)
		{
			List<string> list = new List<string>();
			bool flag = commonColumns == null;
			if (flag)
			{
				List<int> list2 = new List<int>();
				int i = 0;
				int count = dt.Columns.Count;
				while (i < count)
				{
					bool flag2 = i != landscapeColumn && i != valueColumn;
					if (flag2)
					{
						list2.Add(i);
					}
					i++;
				}
				commonColumns = list2.ToArray();
			}
			int num = commonColumns.Length + 1;
			string[] array = new string[num];
			SortedDictionary<string, int> sortedDictionary = new SortedDictionary<string, int>();
			foreach (DataRow dataRow in dt.Rows)
			{
				string text = dataRow[landscapeColumn].ToString();
				bool flag3 = string.IsNullOrEmpty(text);
				if (flag3)
				{
					text = "_";
				}
				bool flag4 = !sortedDictionary.ContainsKey(text);
				if (flag4)
				{
					sortedDictionary[text] = 1;
				}
			}
			DataTable dataTable = new DataTable();
			int num2 = 0;
			int[] array2 = commonColumns;
			DataColumn dataColumn;
			for (int j = 0; j < array2.Length; j++)
			{
				int index = array2[j];
				dataColumn = new DataColumn();
				string text2 = dt.Columns[index].ColumnName;
				list.Add(text2);
				dataColumn.ColumnName = text2;
				dataColumn.DataType = dt.Columns[index].DataType;
				dataTable.Columns.Add(dataColumn);
				array[num2++] = text2;
			}
			string sort = string.Join(",", list.ToArray());
			string columnName = dt.Columns[valueColumn].ColumnName;
			array[num - 1] = columnName;
			Type dataType = dt.Columns[valueColumn].DataType;
			dataColumn = new DataColumn();
			dataColumn.ColumnName = columnName;
			dataColumn.DataType = dataType;
			dataTable.Columns.Add(dataColumn);
			string[] array3 = sortedDictionary.Keys.ToArray<string>();
			int k = 0;
			int num3 = array3.Length;
			while (k < num3)
			{
				dataColumn = new DataColumn();
				dataColumn.ColumnName = "f_" + array3[k];
				dataColumn.DataType = dt.Columns[valueColumn].DataType;
				sortedDictionary[array3[k]] = k + num;
				dataTable.Columns.Add(dataColumn);
				k++;
			}
			DataRow[] array4 = dt.Select("", sort);
			DataRow dataRow2 = dataTable.NewRow();
			int l = 0;
			int num4 = array4.Length;
			while (l < num4)
			{
				string text2 = array4[l][landscapeColumn].ToString();
				bool flag5 = string.IsNullOrEmpty(text2);
				if (flag5)
				{
					text2 = "_";
				}
				int columnIndex = sortedDictionary[text2];
				object obj = array4[l][valueColumn];
				bool flag6 = l == 0;
				bool flag7 = flag6 || !GPFunData.IsSameDataRow(array4[l], array4[l - 1], commonColumns);
				bool flag8 = flag7;
				if (flag8)
				{
					dataRow2 = dataTable.NewRow();
					GPFunData.CopyDataRow(array4[l], dataRow2, array);
					dataTable.Rows.Add(dataRow2);
				}
				else
				{
					double num5 = GPFunctions.CDbl<object>(dataRow2[columnName]) + GPFunctions.CDbl<object>(obj);
					dataRow2[columnName] = Convert.ChangeType(num5, dataType);
				}
				dataRow2[columnIndex] = obj;
				l++;
			}
			return dataTable;
		}

		public static int DataTableSetCaptions(DataTable dataTable, string strCaptions)
		{
			Dictionary<string, string> dictionary = GPFunctions.StringToDict(strCaptions, ',', '=');
			DataColumnCollection columns = dataTable.Columns;
			int num = 0;
			foreach (DataColumn dataColumn in columns)
			{
				string columnName = dataColumn.ColumnName;
				bool flag = dictionary.ContainsKey(columnName);
				if (flag)
				{
					dataColumn.Caption = dictionary[columnName];
					num++;
				}
			}
			return num;
		}

		public static DataTable CreateDataTable<T>(T t) where T : new()
		{
			DataTable dataTable = new DataTable("DataTable");
			PropertyInfo[] properties = t.GetType().GetProperties();
			DataColumnCollection columns = dataTable.Columns;
			PropertyInfo[] array = properties;
			for (int i = 0; i < array.Length; i++)
			{
				PropertyInfo propertyInfo = array[i];
				string name = propertyInfo.Name;
				DataColumn dataColumn = new DataColumn();
				dataColumn.ColumnName = name;
				dataColumn.DataType = propertyInfo.PropertyType;
				string displayName = GPFunData.GetDisplayName(propertyInfo);
				bool flag = !string.IsNullOrEmpty(displayName);
				if (flag)
				{
					dataColumn.Caption = displayName;
				}
				columns.Add(dataColumn);
			}
			return dataTable;
		}

		public static ICollection<KeyValuePair<string, object>> GetDynamicClassByDataRow(DataRow dataRow)
		{
			object obj = new ExpandoObject();
			ICollection<KeyValuePair<string, object>> collection = obj as ICollection<KeyValuePair<string, object>>;
			foreach (DataColumn dataColumn in dataRow.Table.Columns)
			{
				string columnName = dataColumn.ColumnName;
				KeyValuePair<string, object> item = new KeyValuePair<string, object>(columnName, dataRow[columnName]);
				collection.Add(item);
			}
			return collection;
		}

		public static object CreatNewClassByDataRow(DataRow dataRow)
		{
			CSharpCodeProvider cSharpCodeProvider = new CSharpCodeProvider();
			CompilerParameters compilerParameters = new CompilerParameters();
			compilerParameters.GenerateExecutable = false;
			compilerParameters.GenerateInMemory = true;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("public class MyDynamicClass \n");
			stringBuilder.Append("{\n");
			DataColumnCollection columns = dataRow.Table.Columns;
			foreach (DataColumn dataColumn in columns)
			{
				stringBuilder.Append(string.Format("\t{0} {1};", dataColumn.DataType.Name, dataColumn.ColumnName));
			}
			stringBuilder.Append("}");
			CompilerResults compilerResults = cSharpCodeProvider.CompileAssemblyFromSource(compilerParameters, new string[]
			{
				stringBuilder.ToString()
			});
			Assembly compiledAssembly = compilerResults.CompiledAssembly;
			object obj = compiledAssembly.CreateInstance("MyDynamicClass");
			Type type = obj.GetType();
			foreach (DataColumn dataColumn2 in columns)
			{
				PropertyInfo property = type.GetProperty(dataColumn2.ColumnName);
				bool flag = property != null && property.CanRead;
				if (flag)
				{
					property.SetValue(obj, dataRow[dataColumn2.ColumnName], null);
				}
			}
			return obj;
		}

		public static T DataRowToEntity<T>(DataRow dataRow) where T : class, new()
		{
			bool flag = dataRow == null;
			T result;
			if (flag)
			{
				result = default(T);
			}
			else
			{
				T t = Activator.CreateInstance<T>();
				PropertyInfo[] properties = t.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
				PropertyInfo[] array = properties;
				for (int i = 0; i < array.Length; i++)
				{
					PropertyInfo propertyInfo = array[i];
					DataColumnCollection columns = dataRow.Table.Columns;
					string name = propertyInfo.Name;
					int num = columns.IndexOf(name);
					bool flag2 = num >= 0 && dataRow[num] != DBNull.Value;
					if (flag2)
					{
						object value = dataRow[num];
						Type propertyType = propertyInfo.PropertyType;
						bool flag3 = propertyType.IsValueType && propertyType != columns[num].DataType;
						if (flag3)
						{
							value = Convert.ChangeType(value, propertyType);
						}
						propertyInfo.SetValue(t, value, null);
					}
				}
				result = t;
			}
			return result;
		}

		public static T ToEntity<T>(this DataRow dataRow) where T : class, new()
		{
			return GPFunData.DataRowToEntity<T>(dataRow);
		}

		public static T DataRowToEntityFields<T>(DataRow dataRow) where T : class, new()
		{
			bool flag = dataRow == null;
			T result;
			if (flag)
			{
				result = default(T);
			}
			else
			{
				T t = Activator.CreateInstance<T>();
				FieldInfo[] fields = t.GetType().GetFields();
				FieldInfo[] array = fields;
				for (int i = 0; i < array.Length; i++)
				{
					FieldInfo fieldInfo = array[i];
					DataColumnCollection columns = dataRow.Table.Columns;
					string name = fieldInfo.Name;
					int num = columns.IndexOf(name);
					bool flag2 = num >= 0 && dataRow[num] != DBNull.Value;
					if (flag2)
					{
						object value = dataRow[num];
						Type fieldType = fieldInfo.FieldType;
						bool flag3 = fieldType.IsValueType && fieldType != columns[num].DataType;
						if (flag3)
						{
							value = Convert.ChangeType(value, fieldType);
						}
						fieldInfo.SetValue(t, value);
					}
				}
				result = t;
			}
			return result;
        }

        public static DataTable ListToDataTable<T>(List<T> list) where T : new()
        {
            bool flag = list.Count == 0;
            if (flag)
            {
                throw new Exception("ListToDataTable: no data!");
            }
            Type typeFromHandle = typeof(T);
            T t = list[0];
            DataTable dataTable = GPFunData.CreateDataTable<T>(t);
            DataColumnCollection columns = dataTable.Columns;
            PropertyInfo[] properties = typeFromHandle.GetProperties(BindingFlags.Instance | BindingFlags.Public);
            Dictionary<string, IndexType> dictionary = new Dictionary<string, IndexType>();
            PropertyInfo[] array = properties;
            for (int i = 0; i < array.Length; i++)
            {
                PropertyInfo propertyInfo = array[i];
                string name = propertyInfo.Name;
                int num = columns.IndexOf(name);
                bool flag2 = num >= 0;
                if (flag2)
                {
                    IndexType indexType;
                    indexType.index = num;
                    Type propertyType = propertyInfo.PropertyType;
                    bool flag3 = !propertyType.Equals(columns[num].DataType);
                    if (flag3)
                    {
                        indexType.type = 1;
                    }
                    else
                    {
                        indexType.type = 0;
                    }
                    dictionary.Add(name, indexType);
                }
            }
            dataTable.BeginLoadData();
            foreach (T current in list)
            {
                DataRow dataRow = dataTable.NewRow();
                foreach (string current2 in dictionary.Keys)
                {
                    IndexType indexType = dictionary[current2];
                    int index = indexType.index;
                    object obj = typeFromHandle.GetProperty(current2).GetValue(current, null);
                    bool flag4 = obj != null;
                    if (flag4)
                    {
                        bool flag5 = indexType.type == 1;
                        if (flag5)
                        {
                            obj = Convert.ChangeType(obj, columns[index].DataType);
                        }
                        dataRow[index] = obj;
                    }
                }
                dataTable.Rows.Add(dataRow);
            }
            dataTable.EndLoadData();
            dataTable.AcceptChanges();
            return dataTable;
        }

        public static bool DataTableDelete(DataTable table)
        {
			DataRowCollection rows = table.Rows;
			int i = 0;
			int count = rows.Count;
			while (i < count)
			{
				DataRow dataRow = rows[i];
				bool flag = dataRow.RowState != DataRowState.Deleted;
				if (flag)
				{
					dataRow.Delete();
				}
				i++;
			}
			return true;
		}

		public static int GetDataTableChangedCount(DataTable dataTable)
		{
			int num = 0;
			bool flag = dataTable == null;
			int result;
			if (flag)
			{
				result = 0;
			}
			else
			{
				foreach (DataRow dataRow in dataTable.Rows)
				{
					bool flag2 = dataRow.RowState != DataRowState.Unchanged;
					if (flag2)
					{
						num++;
					}
				}
				result = num;
			}
			return result;
		}

		public static bool DataTableCopy(DataTable dataTable, DataTable dtTarget, string[] columns)
		{
			Dictionary<int, int> dictionary = new Dictionary<int, int>();
			int num = columns.Length;
			DataColumnCollection columns2 = dataTable.Columns;
			DataColumnCollection columns3 = dtTarget.Columns;
			bool flag = true;
			for (int i = 0; i < num; i++)
			{
				string text = columns[i];
				int num2 = columns2.IndexOf(text);
				int num3 = columns3.IndexOf(text);
				bool flag2 = num2 < 0;
				if (flag2)
				{
					throw new Exception(string.Format("DataTableCopy：字段{0}不在原DataTable中。", text));
				}
				bool flag3 = num3 < 0;
				if (flag3)
				{
					throw new Exception(string.Format("DataTableCopy：字段{0}不在目标DataTable中。", text));
				}
				dictionary.Add(num2, num3);
				bool flag4 = !columns2[num2].DataType.Equals(columns2[num3].DataType);
				if (flag4)
				{
					flag = false;
				}
			}
			DataRowCollection rows = dataTable.Rows;
			foreach (DataRow dataRow in rows)
			{
				DataRow dataRow2 = dtTarget.NewRow();
				bool flag5 = dataRow.RowState != DataRowState.Deleted;
				if (flag5)
				{
					foreach (KeyValuePair<int, int> current in dictionary)
					{
						bool flag6 = flag;
						if (flag6)
						{
							dataRow2[current.Value] = dataRow[current.Key];
						}
						else
						{
							dataRow2[current.Value] = Convert.ChangeType(dataRow[current.Key], columns3[current.Value].DataType);
						}
					}
				}
				dtTarget.Rows.Add(dataRow2);
			}
			return true;
		} 

        public static bool RemoveLongerItem(Dictionary<string, int> dic, int n)
		{
			string[] array = dic.Keys.ToArray<string>();
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string key = array2[i];
				bool flag = dic[key] >= n;
				if (flag)
				{
					dic.Remove(key);
				}
			}
			return true;
		}

		public static string StartsWithCode(Dictionary<string, int> dic, string codeStr)
		{
			string text = "";
			foreach (KeyValuePair<string, int> current in dic)
			{
				bool flag = codeStr.StartsWith(current.Key);
				if (flag)
				{
					bool flag2 = current.Key.Length > text.Length;
					if (flag2)
					{
						text = current.Key;
						break;
					}
				}
			}
			return text;
		}

		public static void Swap<T>(ref T lhs, ref T rhs)
		{
			T t = lhs;
			lhs = rhs;
			rhs = t;
		}

		public static void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : IComparable<T>
		{
			bool flag = lhs.CompareTo(rhs) > 0;
			if (flag)
			{
				T t = lhs;
				lhs = rhs;
				rhs = t;
			}
		}

		public static void SwapIfLess<T>(ref T lhs, ref T rhs) where T : IComparable<T>
		{
			bool flag = lhs.CompareTo(rhs) < 0;
			if (flag)
			{
				T t = lhs;
				lhs = rhs;
				rhs = t;
			}
		}

		public static List<string> StringToList(string source, string[] cs)
		{
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			string[] array = source.Split(cs, StringSplitOptions.RemoveEmptyEntries);
			string[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				string text = array2[i];
				string text2 = text.Trim();
				bool flag = !string.IsNullOrEmpty(text2);
				if (flag)
				{
					bool flag2 = !dictionary.ContainsKey(text2);
					if (flag2)
					{
						dictionary[text2] = 1;
					}
					else
					{
						dictionary[text2]++;
					}
				}
			}
			return dictionary.Keys.ToList<string>();
		}

		public static List<string> StringToList(string source, string deli)
		{
			string[] cs = new string[]
			{
				deli
			};
			return GPFunData.StringToList(source, cs);
		}

		public static string GetDisplayName(PropertyInfo pInfo)
		{
			Attribute[] array = (Attribute[])pInfo.GetCustomAttributes(typeof(DisplayNameAttribute), false);
			bool flag = array.Length != 0;
			string result;
			if (flag)
			{
				DisplayNameAttribute displayNameAttribute = (DisplayNameAttribute)array[0];
				result = displayNameAttribute.DisplayName;
			}
			else
			{
				result = "";
			}
			return result;
		}

		public static double SumColumnValue(DataTable dataTable, string columnName)
		{
			double num = 0.0;
			foreach (DataRow dataRow in dataTable.Rows)
			{
				num += GPFunctions.CDbl<object>(dataRow[columnName]);
			}
			return num;
		}

		public static double SumColumnValue(DataTable dataTable, int colIndex)
		{
			double num = 0.0;
			foreach (DataRow dataRow in dataTable.Rows)
			{
				num += GPFunctions.CDbl<object>(dataRow[colIndex]);
			}
			return num;
		}

		public static T Clone<T>(T RealObject)
		{
			T result;
			using (Stream stream = new MemoryStream())
			{
				IFormatter formatter = new BinaryFormatter();
				formatter.Serialize(stream, RealObject);
				stream.Seek(0L, SeekOrigin.Begin);
				result = (T)((object)formatter.Deserialize(stream));
			}
			return result;
		}

		public static T CloneEx<T>(T data) where T : new()
		{
			bool flag = data == null;
			if (flag)
			{
				throw new NullReferenceException("CloneEx: data is null ");
			}
			Type type = data.GetType();
			PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
			T t = Activator.CreateInstance<T>();
			Type typeFromHandle = typeof(T);
			PropertyInfo[] array = properties;
			for (int i = 0; i < array.Length; i++)
			{
				PropertyInfo propertyInfo = array[i];
				string name = propertyInfo.Name;
				PropertyInfo property = typeFromHandle.GetProperty(name);
				bool flag2 = property != null;
				if (flag2)
				{
					property.SetValue(t, propertyInfo.GetValue(data, null), null);
				}
			}
			return t;
		}

		public static string[] GetDataTableColumns(DataTable dataTable)
		{
			DataColumnCollection columns = dataTable.Columns;
			int count = columns.Count;
			string[] array = new string[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = columns[i].ColumnName;
			}
			return array;
		}
	}
}