C＃继承类的BindingList< T>不更新控件 [英] C# Inherited class BindingList<T> doesn't update controls
问题描述
我有从继承的BindingList应用排序到的BindingList类。排序工作正常，但是当我在列表中添加或删除项目不更新界控件。我想我错过类的东西，但我不知道是什么。
I have a class which inherits from BindingList to apply sorting to a bindinglist. The sorting works fine, but when I add or remove an item from the list the bounded control isn't updated. I think i miss something in the class, but I don't know what.
我已经找到了类的代码在网上的某个地方，但我不知道在哪里，我发现它。我的问题是，为什么这个类doesn'u更新我的控制，当我更新或删除列表中的项目？
I've found the code of the class somewhere online, but I don't know where I found it. My question is, why does this class doesn'u update my control when I update or remove items from the list?
下面是完整的类
public class SortableBindingList<T> : BindingList<T>
{
#region Membar variables
private bool _isSortedValue;
private ArrayList _sortedList;
private ArrayList _unsortedItems;
private PropertyDescriptor _sortPropertyValue;
private ListSortDirection _sortDirectionValue;
#endregion
#region Constructor
public SortableBindingList()
{
}
public SortableBindingList(IList<T> list):base(list)
{
}
#endregion
#region Overrided Properties
protected override bool SupportsSearchingCore
{
get { return true; }
}
protected override bool SupportsSortingCore
{
get { return true; }
}
protected override bool IsSortedCore
{
get { return _isSortedValue; }
}
protected override PropertyDescriptor SortPropertyCore
{
get { return _sortPropertyValue; }
}
protected override ListSortDirection SortDirectionCore
{
get { return _sortDirectionValue; }
}
#endregion
#region Public methods
public int Find(string property, object key)
{
// Check the properties for a property with the specified name.
PropertyDescriptorCollection properties =
TypeDescriptor.GetProperties(typeof(T));
PropertyDescriptor prop = properties.Find(property, true);
// If there is not a match, return -1 otherwise pass search to
// FindCore method.
if (prop == null)
return -1;
else
return FindCore(prop, key);
}
public void RemoveSort()
{
RemoveSortCore();
}
public void Sort(string property, ListSortDirection direction)
{
// Get all the properties of the object T
PropertyDescriptorCollection properties =
TypeDescriptor.GetProperties(typeof(T));
// Find the specified property in de collection and ignore case
PropertyDescriptor prop = properties.Find(property, true);
if (prop != null)
ApplySortCore(prop, direction);
}
#endregion
#region Overrided methods
// The FindCore method searches a list and returns the index of a found item
protected override int FindCore(PropertyDescriptor prop, object key)
{
// Get the property info for the specified property.
PropertyInfo propInfo = typeof(T).GetProperty(prop.Name);
T item;
if (key != null)
{
// Loop through the items to see if the key
// value matches the property value.
for (int i = 0; i < Count; ++i)
{
item = (T)Items[i];
if (propInfo.GetValue(item, null).Equals(key))
return i;
}
}
return -1;
}
protected override void ApplySortCore(PropertyDescriptor prop, ListSortDirection direction)
{
_sortedList = new ArrayList();
// Check to see if the property type we are sorting by implements
// the IComparable interface.
Type interfaceType = prop.PropertyType.GetInterface("IComparable");
if (interfaceType != null)
{
// If so, set the SortPropertyValue and SortDirectionValue.
_sortPropertyValue = prop;
_sortDirectionValue = direction;
_unsortedItems = new ArrayList(this.Count);
// Loop through each item, adding it the the sortedItems ArrayList.
foreach (Object item in this.Items)
{
_sortedList.Add(prop.GetValue(item));
_unsortedItems.Add(item);
}
// Call Sort on the ArrayList.
_sortedList.Sort();
T temp;
// Check the sort direction and then copy the sorted items
// back into the list.
if (direction == ListSortDirection.Descending)
_sortedList.Reverse();
for (int i = 0; i < this.Count; i++)
{
int position = Find(prop.Name, _sortedList[i]);
if (position != i)
{
temp = this[i];
this[i] = this[position];
this[position] = temp;
}
}
_isSortedValue = true;
// Raise the ListChanged event so bound controls refresh their
// values.
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
else
// If the property type does not implement IComparable, let the user
// know.
throw new NotSupportedException("Cannot sort by " + prop.Name +
". This" + prop.PropertyType.ToString() +
" does not implement IComparable");
}
protected override void RemoveSortCore()
{
int position;
object temp;
// Ensure the list has been sorted.
if (_unsortedItems != null)
{
// Loop through the unsorted items and reorder the
// list per the unsorted list.
for (int i = 0; i < _unsortedItems.Count; )
{
position = this.Find(_sortPropertyValue.Name,
_unsortedItems[i].GetType().GetProperty(_sortPropertyValue.Name).GetValue(_unsortedItems[i], null));
if (position > 0 && position != i)
{
temp = this[i];
this[i] = this[position];
this[position] = (T)temp;
i++;
}
else if (position == i)
i++;
else
// If an item in the unsorted list no longer exists,
// delete it.
_unsortedItems.RemoveAt(i);
}
_isSortedValue = false;
OnListChanged(new ListChangedEventArgs(ListChangedType.Reset, -1));
}
}
#endregion
}
推荐答案
无法重现;它似乎在这里很好：
Cannot reproduce; it seems fine here:
static class Program
{
[STAThread]
static void Main()
{
Button btn;
var data = new SortableBindingList<Foo> { new Foo { Bar = "abc" } };
using (var form = new Form
{
Controls = {
(btn = new Button { Dock = DockStyle.Bottom, Text = "add"}),
new DataGridView { Dock = DockStyle.Fill, DataSource = data,
AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.AllCells }
}
})
{
btn.Click += delegate { data.Add(new Foo { Bar = DateTime.Now.Ticks.ToString()}); };
Application.Run(form);
}
}
}
class Foo
{
public string Bar { get; set; }
}
您可以给一个可重复的例子，它不更新？
Can you give a reproducible example where it doesn't update?
重新注释：该代码是用的东西比较的：
Re the comments: the code is using something comparable to:
data = new BindingList<Foo>(someOtherData.Where(lambda).ToList());
现在，的如果我们加入到 someOtherData 的，我们的确不会注意到任何区别。
Now, if we add to someOtherData, we indeed won't notice any difference. A slight peculiarity of Collection<T> is that if you pass a list into the constructor, that list does become the actual backing list, but:
答：它不能提高任何事件，除非它知道它;它可以知道的唯一途径是，如果它看到除了，即除了经过的BindingList< T>。新增，没有后台列表的添加。这可能会导致在奇数效果，即重新加载或重新绑定数据可以使项神奇地出现（在某些情况下，不是这样的一个）
a: it can't raise any events unless it knows about it; the only way it can know is if it sees the addition, i.e. the addition goes through BindingList<T>.Add, not the backing list's Add. This can cause the odd effect that reloading or rebinding the data can make items magically appear (in some cases, not this one).
A：在这种情况下，背衬名单不是 someOtherData ，而是由LINQ生成一个单独的列表（了ToList（）），所以即使加上东西< 。code> someOtherData 绝不会导致绑定列表支持列表中看到新的项目
b: in this case, the backing list is not someOtherData, but a separate list generated by LINQ (ToList()), so even adding something to someOtherData will never cause the binding-lists backing list to see the new item.
在短期：你需要治疗绑定列表为主如果你希望数据变化进行传播。其他;重新绑定数据。
In short: you need to treat the binding-list as the "master" if you expect data changes to propagate. Else; re-bind the data.
这篇关于C＃继承类的BindingList< T>不更新控件的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
