Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / WinForms / Managed / System / WinForms / BindingSource.cs / 1305376 / BindingSource.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ISupportInitialize.EndInit():System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ICancelAddNew.CancelNew(System.Int32):System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ICancelAddNew.EndNew(System.Int32):System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ISupportInitialize.BeginInit():System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ISupportInitializeNotification.get_IsInitialized():System.Boolean")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.IBindingList.AddIndex(System.ComponentModel.PropertyDescriptor):System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ISupportInitializeNotification.add_Initialized(System.EventHandler):System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.ISupportInitializeNotification.remove_Initialized(System.EventHandler):System.Void")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope="member", Target="System.Windows.Forms.BindingSource.System.ComponentModel.IBindingList.RemoveIndex(System.ComponentModel.PropertyDescriptor):System.Void")]
namespace System.Windows.Forms {
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Globalization;
using System.Reflection;
using System.Security;
using System.Security.Permissions;
using System.Text;
[
DefaultProperty("DataSource"),
DefaultEvent("CurrentChanged"),
ComplexBindingProperties("DataSource", "DataMember"),
Designer("System.Windows.Forms.Design.BindingSourceDesigner, " + AssemblyRef.SystemDesign),
SRDescription(SR.DescriptionBindingSource),
System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1035:ICollectionImplementationsHaveStronglyTypedMembers"), // ICollection.CopyTo: Its just a wrapper class, it doesn't have a specific member type
System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix"), // ICollection: We don't want class name to have to end in 'Collection'
System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1039:ListsAreStronglyTyped"), // IList.Add: Its just a wrapper class, it doesn't have a specific member type
]
/// relatedBindingSources;
// Support for user-overriding of the AllowNew property
private bool allowNewIsSet = false;
private bool allowNewSetValue = true;
// Support for property change event hooking on list items
private object currentItemHookedForItemChange = null;
private object lastCurrentItem = null;
private EventHandler listItemPropertyChangedHandler;
// State data
private int addNewPos = -1;
private bool initializing = false;
private bool needToSetList = false;
private bool recursionDetectionFlag = false;
private bool innerListChanging = false;
private bool endingEdit = false;
///////////////////////////////////////////////////////////////////////////////
//
// Constructors
//
///////////////////////////////////////////////////////////////////////////////
/// ();
}
// Look for an existing binding source that uses this data member, and return that
foreach (string key in this.relatedBindingSources.Keys) {
if (String.Equals(key, dataMember, StringComparison.OrdinalIgnoreCase)) {
return this.relatedBindingSources[key];
}
}
// Otherwise create the related binding source, cache it, and return it
BindingSource bs = new BindingSource(this, dataMember);
this.relatedBindingSources[dataMember] = bs;
return bs;
}
/// where T is only known at run time, not compile time
private static IList CreateBindingList(Type type) {
Type genericType = typeof(BindingList<>);
Type bindingType = genericType.MakeGenericType(new Type[] { type });
return (IList) SecurityUtils.SecureCreateInstance(bindingType);
}
// Create an object of the given type. Throw an exception if this fails.
private static object CreateInstanceOfType(Type type) {
object instancedObject = null;
Exception instanceException = null;
try {
instancedObject = SecurityUtils.SecureCreateInstance(type);
}
catch (TargetInvocationException ex) {
instanceException = ex; // Default ctor threw an exception
}
catch (MethodAccessException ex) {
instanceException = ex; // Default ctor was not public
}
catch (MissingMethodException ex) {
instanceException = ex; // No default ctor defined
}
if (instanceException != null) {
throw new NotSupportedException(SR.GetString(SR.BindingSourceInstanceError), instanceException);
}
return instancedObject;
}
private void CurrencyManager_PositionChanged(object sender, EventArgs e) {
Debug.Assert(sender == this.currencyManager, "only receive notifications from the currency manager");
OnPositionChanged(e);
}
private void CurrencyManager_CurrentChanged(object sender, EventArgs e) {
OnCurrentChanged(EventArgs.Empty);
}
private void CurrencyManager_CurrentItemChanged(object sender, EventArgs e) {
OnCurrentItemChanged(EventArgs.Empty);
}
private void CurrencyManager_BindingComplete(object sender, BindingCompleteEventArgs e) {
OnBindingComplete(e);
}
private void CurrencyManager_DataError(object sender, BindingManagerDataErrorEventArgs e) {
OnDataError(e);
}
///
/// Unhook BindingSource from its data source, since the data source could be some
/// global object who's lifetime exceeds the lifetime of the parent form. Otherwise
/// the BindingSource (and any components bound through it) will end up in limbo,
/// still processing list change events, etc. And when unhooking from the data source,
/// take care not to trigger any events that could confuse compoents bound to us.
///
protected override void Dispose(bool disposing) {
if (disposing) {
UnwireDataSource();
UnwireInnerList();
UnhookItemChangedEventsForOldCurrent();
UnwireCurrencyManager(this.currencyManager);
this.dataSource = null;
this.sort = null;
this.dataMember = null;
this._innerList = null;
this.isBindingList = false;
this.needToSetList = true;
this.raiseListChangedEvents = false;
}
disposedOrFinalized = true;
base.Dispose(disposing);
}
/// from throwing]
SetList(WrapObjectInBindingList(currentValue), false, false);
}
else {
// Nothing to bind to (no current item, or item's property returned null).
// Create an empty list, using the previously determined item type.
// [NOTE: Specify applySortAndFilter=FALSE to stop BindingList from throwing]
SetList(CreateBindingList(this.itemType), false, false);
}
// After a change of child lists caused by a change in the current parent item, we
// should reset the list position (a la RelatedCurrencyManager). But we have to do
// this explicitly, because a CurrencyManager normally tries to preserve its position
// after a list reset event.
// Only reset the position if the list really changed or if the list
// position is incorrect
currentItemChanged = ((null == lastCurrentItem) || (cm.Count == 0) || (lastCurrentItem != cm.Current) || (this.Position >= this.Count));
// Save last current item
lastCurrentItem = cm.Count > 0 ? cm.Current : null;
if (currentItemChanged) {
this.Position = (this.Count > 0 ? 0 : -1);
}
}
OnCurrentItemChanged(EventArgs.Empty);
}
//
// ParentCurrencyManager_MetaDataChanged()
//
// When the data source signals a change of metadata, we need to re-query for the list specified
// by the data member field. If the data member is no longer valid under the data source's new
// metadata, we have no choice but to clear the data member field and just bind directly to the
// data source itself.
//
private void ParentCurrencyManager_MetaDataChanged(object sender, EventArgs e) {
ClearInvalidDataMember();
ResetList();
}
// << Some of this code is taken from System.Data.DataTable::ParseSortString method >>
private ListSortDescriptionCollection ParseSortString(string sortString) {
if (String.IsNullOrEmpty(sortString)) {
return new ListSortDescriptionCollection();
}
ArrayList sorts = new ArrayList();
PropertyDescriptorCollection props = this.currencyManager.GetItemProperties();
string[] split = sortString.Split(new char[] {','});
for (int i = 0; i < split.Length; i++) {
string current = split[i].Trim();
// Handle ASC and DESC
int length = current.Length;
bool ascending = true;
if (length >= 5 && String.Compare(current, length - 4, " ASC", 0, 4, true, CultureInfo.InvariantCulture) == 0) {
current = current.Substring(0, length - 4).Trim();
}
else if (length >= 6 && String.Compare(current, length - 5, " DESC", 0, 5, true, CultureInfo.InvariantCulture) == 0) {
ascending = false;
current = current.Substring(0, length - 5).Trim();
}
// Handle brackets
if (current.StartsWith("[")) {
if (current.EndsWith("]")) {
current = current.Substring(1, current.Length - 2);
}
else {
throw new ArgumentException(SR.GetString(SR.BindingSourceBadSortString));
}
}
// Find the property
PropertyDescriptor prop = props.Find(current, true);
if (prop == null) {
throw new ArgumentException(SR.GetString(SR.BindingSourceSortStringPropertyNotInIBindingList));
}
// Add the sort description
sorts.Add(new ListSortDescription(prop, ascending ? ListSortDirection.Ascending : ListSortDirection.Descending));
}
ListSortDescription[] result = new ListSortDescription[sorts.Count];
sorts.CopyTo(result);
return new ListSortDescriptionCollection(result);
}
/// list argument!");
list = CreateBindingList(this.itemType);
}
// Unwire stuff from the old list
UnwireInnerList();
UnhookItemChangedEventsForOldCurrent();
// Bind to the new list
this._innerList = list;
// Remember whether the new list implements IBindingList
this.isBindingList = (list is IBindingList);
//
// Determine whether the new list converts PropertyChanged events on its items into ListChanged events.
// If it does, then the BindingSource won't need to hook the PropertyChanged events itself. If the list
// implements IRaiseItemChangedEvents, we can ask it directly. Otherwise we will assume that any list
// which impements IBindingList automatically supports this capability.
//
if (list is IRaiseItemChangedEvents) {
this.listRaisesItemChangedEvents = (list as IRaiseItemChangedEvents).RaisesItemChangedEvents;
}
else {
this.listRaisesItemChangedEvents = this.isBindingList;
}
// If list schema may have changed, update list item info now
if (metaDataChanged) {
this.itemType = ListBindingHelper.GetListItemType(List);
this.itemShape = ListBindingHelper.GetListItemProperties(List);
this.itemConstructor = this.itemType.GetConstructor(BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.CreateInstance,
null, new Type[0], null);
}
// Wire stuff up to the new list
WireInnerList();
HookItemChangedEventsForNewCurrent();
// Fire list reset and/or metadata changed events
ResetBindings(metaDataChanged);
//
// Apply any custom Sort and Filter values to the new list.
//
// NOTE: The list will throw a NotSupportedException here if it rejects the new sort
// and filter settings (either because it doesn't support sorting and filtering, or
// because the sort or filter values were invalid).
//
if (applySortAndFilter) {
if (this.Sort != null) {
this.InnerListSort = this.Sort;
}
if (this.Filter != null) {
this.InnerListFilter = this.Filter;
}
}
}
private static IList WrapObjectInBindingList(object obj) {
IList list = CreateBindingList(obj.GetType());
list.Add(obj);
return list;
}
/// relatedBindingSources;
// Support for user-overriding of the AllowNew property
private bool allowNewIsSet = false;
private bool allowNewSetValue = true;
// Support for property change event hooking on list items
private object currentItemHookedForItemChange = null;
private object lastCurrentItem = null;
private EventHandler listItemPropertyChangedHandler;
// State data
private int addNewPos = -1;
private bool initializing = false;
private bool needToSetList = false;
private bool recursionDetectionFlag = false;
private bool innerListChanging = false;
private bool endingEdit = false;
///////////////////////////////////////////////////////////////////////////////
//
// Constructors
//
///////////////////////////////////////////////////////////////////////////////
/// ();
}
// Look for an existing binding source that uses this data member, and return that
foreach (string key in this.relatedBindingSources.Keys) {
if (String.Equals(key, dataMember, StringComparison.OrdinalIgnoreCase)) {
return this.relatedBindingSources[key];
}
}
// Otherwise create the related binding source, cache it, and return it
BindingSource bs = new BindingSource(this, dataMember);
this.relatedBindingSources[dataMember] = bs;
return bs;
}
/// where T is only known at run time, not compile time
private static IList CreateBindingList(Type type) {
Type genericType = typeof(BindingList<>);
Type bindingType = genericType.MakeGenericType(new Type[] { type });
return (IList) SecurityUtils.SecureCreateInstance(bindingType);
}
// Create an object of the given type. Throw an exception if this fails.
private static object CreateInstanceOfType(Type type) {
object instancedObject = null;
Exception instanceException = null;
try {
instancedObject = SecurityUtils.SecureCreateInstance(type);
}
catch (TargetInvocationException ex) {
instanceException = ex; // Default ctor threw an exception
}
catch (MethodAccessException ex) {
instanceException = ex; // Default ctor was not public
}
catch (MissingMethodException ex) {
instanceException = ex; // No default ctor defined
}
if (instanceException != null) {
throw new NotSupportedException(SR.GetString(SR.BindingSourceInstanceError), instanceException);
}
return instancedObject;
}
private void CurrencyManager_PositionChanged(object sender, EventArgs e) {
Debug.Assert(sender == this.currencyManager, "only receive notifications from the currency manager");
OnPositionChanged(e);
}
private void CurrencyManager_CurrentChanged(object sender, EventArgs e) {
OnCurrentChanged(EventArgs.Empty);
}
private void CurrencyManager_CurrentItemChanged(object sender, EventArgs e) {
OnCurrentItemChanged(EventArgs.Empty);
}
private void CurrencyManager_BindingComplete(object sender, BindingCompleteEventArgs e) {
OnBindingComplete(e);
}
private void CurrencyManager_DataError(object sender, BindingManagerDataErrorEventArgs e) {
OnDataError(e);
}
///
/// Unhook BindingSource from its data source, since the data source could be some
/// global object who's lifetime exceeds the lifetime of the parent form. Otherwise
/// the BindingSource (and any components bound through it) will end up in limbo,
/// still processing list change events, etc. And when unhooking from the data source,
/// take care not to trigger any events that could confuse compoents bound to us.
///
protected override void Dispose(bool disposing) {
if (disposing) {
UnwireDataSource();
UnwireInnerList();
UnhookItemChangedEventsForOldCurrent();
UnwireCurrencyManager(this.currencyManager);
this.dataSource = null;
this.sort = null;
this.dataMember = null;
this._innerList = null;
this.isBindingList = false;
this.needToSetList = true;
this.raiseListChangedEvents = false;
}
disposedOrFinalized = true;
base.Dispose(disposing);
}
/// from throwing]
SetList(WrapObjectInBindingList(currentValue), false, false);
}
else {
// Nothing to bind to (no current item, or item's property returned null).
// Create an empty list, using the previously determined item type.
// [NOTE: Specify applySortAndFilter=FALSE to stop BindingList from throwing]
SetList(CreateBindingList(this.itemType), false, false);
}
// After a change of child lists caused by a change in the current parent item, we
// should reset the list position (a la RelatedCurrencyManager). But we have to do
// this explicitly, because a CurrencyManager normally tries to preserve its position
// after a list reset event.
// Only reset the position if the list really changed or if the list
// position is incorrect
currentItemChanged = ((null == lastCurrentItem) || (cm.Count == 0) || (lastCurrentItem != cm.Current) || (this.Position >= this.Count));
// Save last current item
lastCurrentItem = cm.Count > 0 ? cm.Current : null;
if (currentItemChanged) {
this.Position = (this.Count > 0 ? 0 : -1);
}
}
OnCurrentItemChanged(EventArgs.Empty);
}
//
// ParentCurrencyManager_MetaDataChanged()
//
// When the data source signals a change of metadata, we need to re-query for the list specified
// by the data member field. If the data member is no longer valid under the data source's new
// metadata, we have no choice but to clear the data member field and just bind directly to the
// data source itself.
//
private void ParentCurrencyManager_MetaDataChanged(object sender, EventArgs e) {
ClearInvalidDataMember();
ResetList();
}
// << Some of this code is taken from System.Data.DataTable::ParseSortString method >>
private ListSortDescriptionCollection ParseSortString(string sortString) {
if (String.IsNullOrEmpty(sortString)) {
return new ListSortDescriptionCollection();
}
ArrayList sorts = new ArrayList();
PropertyDescriptorCollection props = this.currencyManager.GetItemProperties();
string[] split = sortString.Split(new char[] {','});
for (int i = 0; i < split.Length; i++) {
string current = split[i].Trim();
// Handle ASC and DESC
int length = current.Length;
bool ascending = true;
if (length >= 5 && String.Compare(current, length - 4, " ASC", 0, 4, true, CultureInfo.InvariantCulture) == 0) {
current = current.Substring(0, length - 4).Trim();
}
else if (length >= 6 && String.Compare(current, length - 5, " DESC", 0, 5, true, CultureInfo.InvariantCulture) == 0) {
ascending = false;
current = current.Substring(0, length - 5).Trim();
}
// Handle brackets
if (current.StartsWith("[")) {
if (current.EndsWith("]")) {
current = current.Substring(1, current.Length - 2);
}
else {
throw new ArgumentException(SR.GetString(SR.BindingSourceBadSortString));
}
}
// Find the property
PropertyDescriptor prop = props.Find(current, true);
if (prop == null) {
throw new ArgumentException(SR.GetString(SR.BindingSourceSortStringPropertyNotInIBindingList));
}
// Add the sort description
sorts.Add(new ListSortDescription(prop, ascending ? ListSortDirection.Ascending : ListSortDirection.Descending));
}
ListSortDescription[] result = new ListSortDescription[sorts.Count];
sorts.CopyTo(result);
return new ListSortDescriptionCollection(result);
}
/// list argument!");
list = CreateBindingList(this.itemType);
}
// Unwire stuff from the old list
UnwireInnerList();
UnhookItemChangedEventsForOldCurrent();
// Bind to the new list
this._innerList = list;
// Remember whether the new list implements IBindingList
this.isBindingList = (list is IBindingList);
//
// Determine whether the new list converts PropertyChanged events on its items into ListChanged events.
// If it does, then the BindingSource won't need to hook the PropertyChanged events itself. If the list
// implements IRaiseItemChangedEvents, we can ask it directly. Otherwise we will assume that any list
// which impements IBindingList automatically supports this capability.
//
if (list is IRaiseItemChangedEvents) {
this.listRaisesItemChangedEvents = (list as IRaiseItemChangedEvents).RaisesItemChangedEvents;
}
else {
this.listRaisesItemChangedEvents = this.isBindingList;
}
// If list schema may have changed, update list item info now
if (metaDataChanged) {
this.itemType = ListBindingHelper.GetListItemType(List);
this.itemShape = ListBindingHelper.GetListItemProperties(List);
this.itemConstructor = this.itemType.GetConstructor(BindingFlags.Public |
BindingFlags.Instance |
BindingFlags.CreateInstance,
null, new Type[0], null);
}
// Wire stuff up to the new list
WireInnerList();
HookItemChangedEventsForNewCurrent();
// Fire list reset and/or metadata changed events
ResetBindings(metaDataChanged);
//
// Apply any custom Sort and Filter values to the new list.
//
// NOTE: The list will throw a NotSupportedException here if it rejects the new sort
// and filter settings (either because it doesn't support sorting and filtering, or
// because the sort or filter values were invalid).
//
if (applySortAndFilter) {
if (this.Sort != null) {
this.InnerListSort = this.Sort;
}
if (this.Filter != null) {
this.InnerListFilter = this.Filter;
}
}
}
private static IList WrapObjectInBindingList(object obj) {
IList list = CreateBindingList(obj.GetType());
list.Add(obj);
return list;
}
///