public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
StringCollection values = null;
if (context != null && context.Instance != null && context.Instance is DataBindingRuleBase)
{
try
{
object obj = null;
DataBindingRuleBase dataBindingRuleBase = (DataBindingRuleBase)context.Instance;
obj = dataBindingRuleBase.DataSource;
if (obj != null)
{
values = DataBindingHelper.GetDataSourceCoordinateFields(obj, dataBindingRuleBase.DataMember, dataBindingRuleBase.BindingField);
}
}
catch
{
}
}
return(new StandardValuesCollection(values));
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList values = new ArrayList();
if (context != null && context.Instance != null && context.Instance is DataBindingRuleBase)
{
try
{
object obj = null;
DataBindingRuleBase dataBindingRuleBase = (DataBindingRuleBase)context.Instance;
obj = dataBindingRuleBase.DataSource;
if (obj != null)
{
values = DataBindingHelper.GetDataSourceDataFields(obj, dataBindingRuleBase.DataMember, string.Empty);
}
}
catch
{
}
}
return(new StandardValuesCollection(values));
}
public static void InitDesignDataTable(object dataSource, string dataMember, DataTable designDataTable)
{
if (dataSource != null)
{
designDataTable.Clear();
designDataTable.Columns.Clear();
try
{
ArrayList dataSourceDataFields = DataBindingHelper.GetDataSourceDataFields(dataSource, dataMember, string.Empty);
if (dataSourceDataFields.Count != 0)
{
foreach (DataFieldDescriptor item in dataSourceDataFields)
{
designDataTable.Columns.Add(item.Name, Field.ConvertToSupportedType(item.Type));
}
}
}
catch (Exception)
{
}
}
}
public DesignDataTableSource(MapCore mapCore, object originalDataSource)
{
DataBindingHelper.InitDesignDataTable(originalDataSource, string.Empty, this);
}
public static bool HasRealData(object dataSource)
{
StringCollection dataSourceDataMembers = DataBindingHelper.GetDataSourceDataMembers(dataSource);
if (dataSourceDataMembers.Count == 0)
{
bool flag = false;
IDbConnection dbConnection = null;
IEnumerable dataSourceAsIEnumerable = DataBindingHelper.GetDataSourceAsIEnumerable(dataSource, (string)null, out flag, out dbConnection);
try
{
IEnumerator enumerator = dataSourceAsIEnumerable.GetEnumerator();
try
{
if (enumerator.MoveNext())
{
object current2 = enumerator.Current;
return(true);
}
}
finally
{
IDisposable disposable2 = enumerator as IDisposable;
if (disposable2 != null)
{
disposable2.Dispose();
}
}
}
finally
{
if (flag)
{
((IDataReader)dataSourceAsIEnumerable).Close();
}
if (dbConnection != null)
{
dbConnection.Close();
}
}
}
else
{
StringEnumerator enumerator2 = dataSourceDataMembers.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
string current = enumerator2.Current;
bool flag2 = false;
IDbConnection dbConnection2 = null;
IEnumerable dataSourceAsIEnumerable2 = DataBindingHelper.GetDataSourceAsIEnumerable(dataSource, current, out flag2, out dbConnection2);
try
{
IEnumerator enumerator3 = dataSourceAsIEnumerable2.GetEnumerator();
try
{
if (enumerator3.MoveNext())
{
object current3 = enumerator3.Current;
return(true);
}
}
finally
{
IDisposable disposable3 = enumerator3 as IDisposable;
if (disposable3 != null)
{
disposable3.Dispose();
}
}
}
finally
{
if (flag2)
{
((IDataReader)dataSourceAsIEnumerable2).Close();
}
if (dbConnection2 != null)
{
dbConnection2.Close();
}
}
}
}
finally
{
IDisposable disposable = enumerator2 as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
return(false);
}
public static ArrayList GetDataSourceDataFields(object dataSource, string dataMember, string fieldToExclude)
{
ArrayList arrayList = new ArrayList();
if (dataSource != null)
{
try
{
if (dataSource.GetType().GetInterface("IDataSource") != null)
{
try
{
MethodInfo method = dataSource.GetType().GetMethod("Select");
if (method != null)
{
if (method.GetParameters().Length == 1)
{
Type type = dataSource.GetType().Assembly.GetType("System.Web.UI.DataSourceSelectArguments", true);
ConstructorInfo constructor = type.GetConstructor(new Type[0]);
dataSource = method.Invoke(dataSource, new object[1]
{
constructor.Invoke(new object[0])
});
}
else
{
dataSource = method.Invoke(dataSource, new object[0]);
}
}
}
catch
{
}
}
DataTable dataTable = null;
if (dataSource is BindingSource)
{
BindingSource bindingSource = (BindingSource)dataSource;
string dataMember2 = bindingSource.DataMember;
try
{
if (string.IsNullOrEmpty(dataMember))
{
dataMember = DataBindingHelper.GetDataSourceDefaultDataMember(bindingSource);
}
bindingSource.DataMember = dataMember;
foreach (PropertyDescriptor itemProperty in bindingSource.GetItemProperties(null))
{
if (itemProperty.Name != fieldToExclude)
{
arrayList.Add(new DataFieldDescriptor(itemProperty.Name, itemProperty.PropertyType));
}
}
}
finally
{
bindingSource.DataMember = dataMember2;
}
}
else if (dataSource is DataTable)
{
dataTable = (DataTable)dataSource;
}
else if (dataSource is DataView)
{
dataTable = ((DataView)dataSource).Table;
}
else if (dataSource is DataSet && ((DataSet)dataSource).Tables.Count > 0)
{
dataTable = ((!string.IsNullOrEmpty(dataMember)) ? ((DataSet)dataSource).Tables[dataMember] : ((DataSet)dataSource).Tables[0]);
}
else if (dataSource is IDataAdapter)
{
DataSet dataSet = new DataSet();
dataSet.Locale = CultureInfo.CurrentCulture;
DataTable[] array = ((IDataAdapter)dataSource).FillSchema(dataSet, SchemaType.Mapped);
if (array.Length > 0)
{
dataTable = array[0];
}
}
else if (dataSource is IDataReader)
{
IDataReader dataReader = (IDataReader)dataSource;
if (!dataReader.IsClosed)
{
DataTable schemaTable = dataReader.GetSchemaTable();
if (schemaTable != null)
{
foreach (DataRow row in schemaTable.Rows)
{
string text = (string)row["ColumnName"];
Type type2 = (Type)row["DataType"];
if (text != fieldToExclude)
{
arrayList.Add(new DataFieldDescriptor(text, type2));
}
}
}
}
}
else if (dataSource is IDbCommand)
{
IDbCommand dbCommand = (IDbCommand)dataSource;
IDataReader dataReader2 = null;
if (dbCommand.Connection != null)
{
try
{
dbCommand.Connection.Open();
dataReader2 = dbCommand.ExecuteReader();
DataTable schemaTable2 = dataReader2.GetSchemaTable();
if (schemaTable2 != null)
{
foreach (DataRow row2 in schemaTable2.Rows)
{
string text2 = (string)row2["ColumnName"];
Type type3 = (Type)row2["DataType"];
if (text2 != fieldToExclude)
{
arrayList.Add(new DataFieldDescriptor(text2, type3));
}
}
}
dataReader2.Close();
}
finally
{
if (dbCommand.Connection != null && dbCommand.Connection.State != 0)
{
dbCommand.Connection.Close();
}
if (dataReader2 != null && !dataReader2.IsClosed)
{
dataReader2.Close();
}
}
}
}
if (dataTable != null)
{
{
foreach (DataColumn column in dataTable.Columns)
{
if (column.ColumnName != fieldToExclude)
{
arrayList.Add(new DataFieldDescriptor(column.ColumnName, column.DataType));
}
}
return(arrayList);
}
}
if (arrayList.Count == 0 && dataSource is ITypedList)
{
{
foreach (PropertyDescriptor itemProperty2 in ((ITypedList)dataSource).GetItemProperties(null))
{
if (itemProperty2.PropertyType != typeof(string) && itemProperty2.Name != fieldToExclude)
{
arrayList.Add(new DataFieldDescriptor(itemProperty2.Name, itemProperty2.PropertyType));
}
}
return(arrayList);
}
}
if (arrayList.Count == 0)
{
if (dataSource is IEnumerable)
{
IEnumerator enumerator6 = ((IEnumerable)dataSource).GetEnumerator();
enumerator6.Reset();
enumerator6.MoveNext();
{
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(enumerator6.Current))
{
if (property.PropertyType != typeof(string) && property.Name != fieldToExclude)
{
arrayList.Add(new DataFieldDescriptor(property.Name, property.PropertyType));
}
}
return(arrayList);
}
}
return(arrayList);
}
return(arrayList);
}
catch
{
return(arrayList);
}
}
return(arrayList);
}
public static IEnumerable GetDataSourceAsIEnumerable(object data, string dataMember, out bool closeDataReader, out IDbConnection connection)
{
object obj = data;
closeDataReader = false;
connection = null;
if (obj != null)
{
try
{
if (obj is BindingSource)
{
BindingSource bindingSource = (BindingSource)obj;
string dataMember2 = bindingSource.DataMember;
try
{
if (string.IsNullOrEmpty(dataMember))
{
dataMember = DataBindingHelper.GetDataSourceDefaultDataMember(bindingSource);
}
bindingSource.DataMember = dataMember;
obj = bindingSource.List;
}
finally
{
bindingSource.DataMember = dataMember2;
}
}
if (obj is IDbDataAdapter)
{
obj = ((IDbDataAdapter)obj).SelectCommand;
}
if (obj is DataSet && ((DataSet)obj).Tables.Count > 0)
{
obj = ((!(dataMember == string.Empty) && ((DataSet)obj).Tables.Count != 1) ? ((DataSet)obj).Tables[dataMember] : ((DataSet)obj).Tables[0]);
}
if (obj is DataTable)
{
obj = new DataView((DataTable)obj);
}
else if (obj is IDbCommand)
{
if (((IDbCommand)obj).Connection.State != ConnectionState.Open)
{
connection = ((IDbCommand)obj).Connection;
connection.Open();
}
obj = ((IDbCommand)obj).ExecuteReader();
closeDataReader = true;
}
else
{
obj = (obj as IEnumerable);
}
}
catch (Exception innerException)
{
throw new ApplicationException(SR.bad_data_src, innerException);
}
return(obj as IEnumerable);
}
return(null);
}
