Winforms绑定列表框中的SelectedItems

我希望使用标准列表框将其绑定到一组对象，并更新绑定的项集合以包括选定的项

所以我有点像：

    _pContext = new BindingSource();
_pContext.DataSource = _gpContext;
_pContext.DataMember = "ParentEntities";
_AllChildrenListBox.DataSource = _container.ChildEntities;
_AllChildrenListBox.DataBindings.Add("MySelectedItems", _pContext, "ChildEntities", false);

_allChildrenListBox是列表框。我创建了一个从listbox继承的新listbox类型，以便可以创建一个可选的SelectedItems属性，该属性随后将封装设置/取消设置项的逻辑

---

简而言之，问题是：在上面，ChildEntities是“ChildEntity”对象的集合。我的列表框包含所有可能的ChildEntity对象，我希望选择ChildEntities中的元素，并在选择更改时进行更新。

我找到了解决方法。现在有点难看，但效果不错。我可以在以后改进它

所以第一点是绑定本身

_AllChildrenListBox.DataBindings.Add("SelectedItems2", _pContext, "ChildEntities2", true);

这里的关键似乎是将格式化参数设置为true

接下来，我需要SelectedItems2中的一些东西来完成我的脏活。这是一个混乱，但工作。下面是完整的课程：

    public class MyListBox : ListBox
{
    private IEnumerable<object> _original;

    public IEnumerable<object> SelectedItems2
    {
        get
        {
            return UpdateSet();
        }
        set
        {
            SelectItems(value);
        }
    }

    private IEnumerable<object> UpdateSet()
    {
        var listSource = _original as IListSource;
        IList list = null;
        if (listSource != null)
        {
            list = listSource.GetList();
        }
        var iList = _original as IList;
        if (list == null && iList != null)
        {
            list = iList;
        }
        if (list == null)
        {
            return _original;
        }

        foreach (var item in SelectedItems)
        {
            if (!list.Contains(item))
            {
                list.Add(item);
            }
        }
        foreach (var item in _original.ToList())
        {
            if (!SelectedItems.Contains(item))
            {
                list.Remove(item);
            }
        }

        return _original;

    }

    private void SelectItems(IEnumerable<object> items)
    {
        _original = items;
        var hashset = new HashSet<object>();
        foreach (var item in items)
        {
            hashset.Add(item);
        }
        for(var i=0;i<Items.Count;i++)
        {
            SetSelected(i, hashset.Contains(Items[i]));
        }
    }
}

公共类MyListBox:ListBox
{
私人IEnumerable_原件；
公共IEnumerable SelectedItems2
{
得到
{
返回UpdateSet（）；
}
设置
{
选择项目（值）；
}
}
私有IEnumerable更新集（）
{
var listSource=_原始为IListSource；
IList list=null；
if（listSource！=null）
{
list=listSource.GetList（）；
}
var iList=_原始为iList；
if（list==null&&iList！=null）
{
列表=iList；
}
if（list==null）
{
返回原件；
}
foreach（SelectedItems中的变量项）
{
如果（！list.Contains（项））
{
列表。添加（项目）；
}
}
foreach（原始.ToList（）中的变量项）
{
如果（！SelectedItems.Contains（项））
{
列表。删除（项目）；
}
}
返回原件；
}
私有void SelectItems（IEnumerable items）
{
_原始=项目；
var hashset=新hashset（）；
foreach（项目中的var项目）
{
hashset.Add（项）；
}
对于（var i=0；i！value.Contains（item）））
{
子实体。删除（项）；
}
foreach（价值中的var项目）
{
var cItem=作为子实体的项目；
if（cItem！=null）
{
如果（！ChildEntities.Contains（项作为ChildEntity））
{
添加（作为ChildEntity的项）；
}
}
}                
}
}
}

仅供参考，这是一个真正的黑客攻击，而且只是概念证明。如果你知道更干净的方法，我会感兴趣的。

    public partial class ParentEntity
{
    public IEnumerable<object> ChildEntities2
    {
        get
        {
            return new List<object>(ChildEntities);
        }
        set
        {
            if (value == null)
            {
                return;
            }
            foreach (var item in ChildEntities.ToList().Where(item => !value.Contains(item)))
            {
                ChildEntities.Remove(item);
            }

            foreach (var item in value)
            {
                var cItem = item as ChildEntity;
                if (cItem != null)
                {
                    if (!ChildEntities.Contains(item as ChildEntity))
                    {
                        ChildEntities.Add(item as ChildEntity);
                    }
                }
            }                
        }
    }
}