private void WireDataSource()
{
// If the source is a component, then hook the Disposed event,
// so we know when the component is deleted from the form
if (this.dataSource is IComponent)
{
((IComponent)this.dataSource).Disposed += new EventHandler(DataSourceDisposed);
}
ISupportInitializeNotification dsInit = (this.dataSource as ISupportInitializeNotification);
if (dsInit != null && !dsInit.IsInitialized)
{
// If the source provides initialization notification, and is not yet
// fully initialized, then hook the Initialized event, so that we can
// delay connecting to it until it *is* initialized.
dsInit.Initialized += new EventHandler(DataSourceInitialized);
isDataSourceInitEventHooked = true;
isDataSourceInitialized = false;
}
else
{
// Otherwise either the data source says it *is* initialized, or it
// does not support the capability to report whether its initialized,
// in which case we have to just assume it that is initialized.
isDataSourceInitialized = true;
}
}
public void BeginInitEndInit_WithInitializedEvent_CallsEvent()
{
using var bindingSource = new BindingSource();
ISupportInitializeNotification source = bindingSource;
int callCount = 0;
EventHandler handler = (sender, e) =>
{
callCount++;
Assert.Same(source, sender);
Assert.Equal(EventArgs.Empty, e);
};
source.Initialized += handler;
source.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(1, callCount);
source.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(2, callCount);
// Remove handler.
source.Initialized -= handler;
source.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(2, callCount);
}
public void ISupportInitializeNotification_GetProperties_ReturnsExpected()
{
using var bindingSource = new BindingSource();
ISupportInitializeNotification source = bindingSource;
Assert.True(source.IsInitialized);
}
public void BeginInitEndInit_WithISupportInitializeNotificationDataSourceInitialized_DoesNotWaitForDataSourceInitialize()
{
var dataSource = new ISupportInitializeNotificationDataSource {
IsInitializedResult = true
};
using var bindingSource = new BindingSource(dataSource, nameof(ISupportInitializeNotificationDataSource.Member));
ISupportInitializeNotification source = bindingSource;
int callCount = 0;
EventHandler handler = (sender, e) =>
{
callCount++;
Assert.Same(source, sender);
Assert.Equal(EventArgs.Empty, e);
};
source.Initialized += handler;
source.BeginInit();
Assert.False(source.IsInitialized);
Assert.Equal(0, callCount);
source.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(1, callCount);
// Call again.
source.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(2, callCount);
}
void DataSourceEndInitHandler(object o, EventArgs args)
{
((ISupportInitializeNotification)datasource).Initialized -= DataSourceEndInitHandler;
ISupportInitializeNotification inotif = (ISupportInitializeNotification)this;
inotif.EndInit();
}
private void DataSourceInitialized(object sender, EventArgs e)
{
ISupportInitializeNotification dsInit = (this.dataSource as ISupportInitializeNotification);
Debug.Assert(dsInit != null, "ListControl: ISupportInitializeNotification.Initialized event received, but current DataSource does not support ISupportInitializeNotification!");
Debug.Assert(dsInit.IsInitialized, "ListControl: DataSource sent ISupportInitializeNotification.Initialized event but before it had finished initializing.");
SetDataConnection(this.dataSource, this.displayMember, true);
}
private void supportInitializeDataSource_Initialized(object sender, EventArgs e)
{
ISupportInitializeNotification initializeNotification = sender as ISupportInitializeNotification;
if (initializeNotification != null)
{
initializeNotification.Initialized -= new EventHandler(this.supportInitializeDataSource_Initialized);
}
this.TrySubscribeControls();
}
private void notification_Initialized(object sender, EventArgs e)
{
ISupportInitializeNotification dataSource = this.dataSource as ISupportInitializeNotification;
if (dataSource != null)
{
dataSource.Initialized -= new EventHandler(this.notification_Initialized);
}
this.Bind(this.dataSource, this.dataMember);
}
public void BeginInitEndInit_Invoke_Success()
{
using var bindingSource = new BindingSource();
ISupportInitializeNotification source = bindingSource;
source.BeginInit();
Assert.False(source.IsInitialized);
source.EndInit();
Assert.True(source.IsInitialized);
}
private void DataSource_Initialized(object sender, EventArgs e)
{
ISupportInitializeNotification dataSource = this.dataSource as ISupportInitializeNotification;
if (dataSource != null)
{
dataSource.Initialized -= new EventHandler(this.DataSource_Initialized);
}
this.waitingOnDataSource = false;
this.dataSourceInitialized = true;
this.CheckBinding();
}
private void UnwireDataSource()
{
if (this.dataSource is IComponent)
{
((IComponent)this.dataSource).Disposed -= new EventHandler(this.DataSourceDisposed);
}
ISupportInitializeNotification dataSource = this.dataSource as ISupportInitializeNotification;
if ((dataSource != null) && this.isDataSourceInitEventHooked)
{
dataSource.Initialized -= new EventHandler(this.DataSourceInitialized);
this.isDataSourceInitEventHooked = false;
}
}
private void UnwireDataSource()
{
if (_dataSource is IComponent)
{
((IComponent)_dataSource).Disposed -= new EventHandler(this.DataSourceDisposed);
}
ISupportInitializeNotification notification = _dataSource as ISupportInitializeNotification;
if ((notification != null) && _isDataSourceInitEventHooked)
{
notification.Initialized -= new EventHandler(this.DataSourceInitialized);
_isDataSourceInitEventHooked = false;
}
}
private void UnwireDataSource() {
// If the source is a component, then unhook the Disposed event
if (this.dataSource is IComponent) {
((IComponent) this.dataSource).Disposed -= new EventHandler(DataSourceDisposed);
}
ISupportInitializeNotification dsInit = (this.dataSource as ISupportInitializeNotification);
if (dsInit != null && isDataSourceInitEventHooked) {
// If we previously hooked the data source's ISupportInitializeNotification
// Initialized event, then unhook it now (we don't always hook this event,
// only if we needed to because the data source was previously uninitialized)
dsInit.Initialized -= new EventHandler(DataSourceInitialized);
isDataSourceInitEventHooked = false;
}
}
/// <summary>
/// Sets the data source to the BindingProviderBase. This triggers items creation and removal or previous binding.
/// </summary>
public void SetDataSource(object value, string bindingPath)
{
this.bindingPath = bindingPath;
if (this.dataSource == value)
{
return;
}
if (this.dataSource is IComponent)
{
(this.dataSource as IComponent).Disposed -= BindingProviderBase_Disposed;
}
if (this.dataSource is ISupportInitializeNotification)
{
(this.dataSource as ISupportInitializeNotification).Initialized -= new EventHandler(BindingProviderBase_Initialized);
}
this.dataSource = value;
if (this.dataSource is ISupportInitializeNotification)
{
ISupportInitializeNotification tmp = this.dataSource as ISupportInitializeNotification;
tmp.Initialized += BindingProviderBase_Initialized;
if (!tmp.IsInitialized)
{
return;
}
}
if (this.bindingContext == null)
{
return;
}
if (this.dataSource != null)
{
Bind(this.dataSource);
}
else
{
Unbind();
}
}
public override void EndInit()
{
base.EndInit();
if (this.Site != null || this.DataSource == null)
{
return;
}
ISupportInitializeNotification dataSource = this.DataSource as ISupportInitializeNotification;
if (dataSource != null && !dataSource.IsInitialized)
{
dataSource.Initialized += new EventHandler(this.supportInitializeDataSource_Initialized);
}
else
{
this.TrySubscribeControls();
}
}
private void WireDataSource()
{
if (this.dataSource is IComponent)
{
((IComponent)this.dataSource).Disposed += new EventHandler(DataSourceDisposed);
}
ISupportInitializeNotification dataSource = this.dataSource as ISupportInitializeNotification;
if ((dataSource != null) && !dataSource.IsInitialized)
{
dataSource.Initialized += new EventHandler(DataSourceInitialized);
isDataSourceInitEventHooked = true;
isDataSourceInitialized = false;
}
else
{
isDataSourceInitialized = true;
}
}
public void BeginInitEndInit_SetDataSourceInInit_Success(object newDataSource)
{
var dataSource = new ISupportInitializeNotificationDataSource {
IsInitializedResult = false
};
using var bindingSource = new BindingSource(dataSource, nameof(ISupportInitializeNotificationDataSource.Member));
ISupportInitializeNotification source = bindingSource;
int callCount = 0;
EventHandler handler = (sender, e) =>
{
callCount++;
Assert.Same(source, sender);
Assert.Equal(EventArgs.Empty, e);
};
source.Initialized += handler;
dataSource.Initialized += (sender, e) =>
{
((BindingSource)source).DataSource = newDataSource;
};
source.BeginInit();
Assert.False(source.IsInitialized);
Assert.Equal(0, callCount);
// Call the source init - should not initialize and should instead wait for
// the data source initialization.
source.EndInit();
Assert.False(source.IsInitialized);
Assert.Equal(0, callCount);
// Then, call the data source init.
dataSource.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(1, callCount);
// Call again.
source.EndInit();
Assert.True(source.IsInitialized);
Assert.Equal(2, callCount);
}
private void Bind(object dataSource, string dataMember)
{
this.dataSource = dataSource;
this.dataMember = dataMember;
this.UnWireEvents();
object currencyManager = this.currencyManager;
if (this.bindingContext != null && (this.dataSource != null) && (this.dataSource != Convert.DBNull))
{
ISupportInitializeNotification notification = this.dataSource as ISupportInitializeNotification;
if ((notification != null) && !notification.IsInitialized)
{
notification.Initialized += new EventHandler(notification_Initialized);
this.currencyManager = null;
}
else
{
this.currencyManager = this.bindingContext[this.dataSource, this.dataMember] as System.Windows.Forms.CurrencyManager;
BindToEnumerable();
if (this.currencyManager != null)
{
this.itemType = ListBindingHelper.GetListItemType(this.currencyManager.List);
this.itemConstructor = this.itemType.GetConstructor(BindingFlags.CreateInstance | BindingFlags.Public | BindingFlags.Instance, null, new Type[0], null);
}
}
}
else
{
this.currencyManager = null;
}
this.WireEvents();
if (currencyManager != this.currencyManager)
{
Initialize();
}
}
private void Bind(object dataSource, string dataMember)
{
this.dataSource = dataSource;
this.dataMember = dataMember;
this.UnWireEvents();
CurrencyManager currencyManager = this.currencyManager;
if (this.bindingContext != null && this.dataSource != null && this.dataSource != Convert.DBNull)
{
ISupportInitializeNotification dataSource1 = this.dataSource as ISupportInitializeNotification;
if (dataSource1 != null && !dataSource1.IsInitialized)
{
dataSource1.Initialized += new EventHandler(this.notification_Initialized);
this.currencyManager = (CurrencyManager)null;
}
else
{
this.currencyManager = this.bindingContext[this.dataSource, this.dataMember] as CurrencyManager;
this.BindToEnumerable();
if (this.currencyManager != null)
{
this.itemType = ListBindingHelper.GetListItemType((object)this.currencyManager.List);
this.itemConstructor = this.itemType.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, (Binder)null, new System.Type[0], (ParameterModifier[])null);
}
}
}
else
{
this.currencyManager = (CurrencyManager)null;
if (currencyManager != null && currencyManager.List != null && currencyManager.Position >= currencyManager.List.Count)
{
currencyManager.Position = -1;
}
}
this.WireEvents();
if (!this.Rebuild(currencyManager) || currencyManager == this.currencyManager)
{
return;
}
this.Initialize();
}
private void DataSource_Initialized(object sender, EventArgs e)
{
Debug.Assert(sender == this.dataSource, "data source should not change");
Debug.Assert(this.dataSource is ISupportInitializeNotification, "data source should not change on the BindToObject");
Debug.Assert(this.waitingOnDataSource);
ISupportInitializeNotification ds = this.dataSource as ISupportInitializeNotification;
// Unhook the Initialized event.
if (ds != null)
{
ds.Initialized -= new EventHandler(DataSource_Initialized);
}
// The wait is over: DataSource is initialized.
this.waitingOnDataSource = false;
this.dataSourceInitialized = true;
// Rebind.
CheckBinding();
}
void ISupportInitialize.EndInit()
{
if (datasource != null && datasource is ISupportInitializeNotification)
{
ISupportInitializeNotification inotif = (ISupportInitializeNotification)datasource;
if (!inotif.IsInitialized)
{
inotif.Initialized += DataSourceEndInitHandler;
return;
}
}
is_initialized = true;
ResetList();
EventHandler eh = (EventHandler)Events [InitializedEvent];
if (eh != null)
{
eh(this, EventArgs.Empty);
}
}
private void RefreshColumnCollection()
{
DataGridView component = (DataGridView)base.Component;
ISupportInitializeNotification dataSource = component.DataSource as ISupportInitializeNotification;
if ((dataSource == null) || dataSource.IsInitialized)
{
IComponentChangeService service = null;
PropertyDescriptor member = null;
IDesignerHost provider = base.Component.Site.GetService(typeof(IDesignerHost)) as IDesignerHost;
if (!this.ProcessSimilarSchema(component))
{
PropertyDescriptorCollection itemProperties = null;
if (this.cm != null)
{
try
{
itemProperties = this.cm.GetItemProperties();
}
catch (ArgumentException exception)
{
throw new InvalidOperationException(System.Design.SR.GetString("DataGridViewDataSourceNoLongerValid"), exception);
}
}
IContainer container = (component.Site != null) ? component.Site.Container : null;
service = base.Component.Site.GetService(typeof(IComponentChangeService)) as IComponentChangeService;
member = TypeDescriptor.GetProperties(base.Component)["Columns"];
service.OnComponentChanging(base.Component, member);
DataGridViewColumn[] columnArray = new DataGridViewColumn[component.Columns.Count];
int index = 0;
for (int i = 0; i < component.Columns.Count; i++)
{
DataGridViewColumn column = component.Columns[i];
if (!string.IsNullOrEmpty(column.DataPropertyName))
{
PropertyDescriptor descriptor2 = TypeDescriptor.GetProperties(column)["UserAddedColumn"];
if ((descriptor2 == null) || !((bool)descriptor2.GetValue(column)))
{
columnArray[index] = column;
index++;
}
}
}
for (int j = 0; j < index; j++)
{
component.Columns.Remove(columnArray[j]);
}
service.OnComponentChanged(base.Component, member, null, null);
if (container != null)
{
for (int m = 0; m < index; m++)
{
container.Remove(columnArray[m]);
}
}
DataGridViewColumn[] columnArray2 = null;
int num5 = 0;
if (component.DataSource != null)
{
columnArray2 = new DataGridViewColumn[itemProperties.Count];
num5 = 0;
for (int n = 0; n < itemProperties.Count; n++)
{
System.Type typeofDataGridViewImageColumn;
DataGridViewColumn column2 = null;
TypeConverter converter = TypeDescriptor.GetConverter(typeof(Image));
System.Type propertyType = itemProperties[n].PropertyType;
if (typeof(IList).IsAssignableFrom(propertyType))
{
if (!converter.CanConvertFrom(propertyType))
{
continue;
}
typeofDataGridViewImageColumn = DataGridViewDesigner.typeofDataGridViewImageColumn;
}
else if ((propertyType == typeof(bool)) || (propertyType == typeof(CheckState)))
{
typeofDataGridViewImageColumn = typeofDataGridViewCheckBoxColumn;
}
else if (typeof(Image).IsAssignableFrom(propertyType) || converter.CanConvertFrom(propertyType))
{
typeofDataGridViewImageColumn = DataGridViewDesigner.typeofDataGridViewImageColumn;
}
else
{
typeofDataGridViewImageColumn = typeofDataGridViewTextBoxColumn;
}
string name = ToolStripDesigner.NameFromText(itemProperties[n].Name, typeofDataGridViewImageColumn, base.Component.Site);
column2 = TypeDescriptor.CreateInstance(provider, typeofDataGridViewImageColumn, null, null) as DataGridViewColumn;
column2.DataPropertyName = itemProperties[n].Name;
column2.HeaderText = !string.IsNullOrEmpty(itemProperties[n].DisplayName) ? itemProperties[n].DisplayName : itemProperties[n].Name;
column2.Name = itemProperties[n].Name;
column2.ValueType = itemProperties[n].PropertyType;
column2.ReadOnly = itemProperties[n].IsReadOnly;
provider.Container.Add(column2, name);
columnArray2[num5] = column2;
num5++;
}
}
service.OnComponentChanging(base.Component, member);
for (int k = 0; k < num5; k++)
{
columnArray2[k].DisplayIndex = -1;
component.Columns.Add(columnArray2[k]);
}
service.OnComponentChanged(base.Component, member, null, null);
}
}
}
