如何通过删除与所有列表框关联的一项来从多个列表框中删除项？

Question

我想从它的列表框中删除Server1，我希望它也删除与它关联的其他列表框中的所有其他项目。 （“ Server-Domain1”和所有“ Server1-Domain1-CSR”）。 有没有办法做到这一点？

要“绑定”我刚刚使用的这些列表框：

domainListBox.Items.Add((serverListBox.SelectedItem) + "-" + (this.domainTextbox.Text));

和

        csrListBox.Items.Add((domainListBox.SelectedItem) + ("-CSR-1"));
        csrListBox.Items.Add((domainListBox.SelectedItem) + ("-CSR-2"));
        csrListBox.Items.Add((domainListBox.SelectedItem) + ("-CSR-3"));

Answer 1

创建一个封装Server及其详细信息的类，例如Domains和Csrs 。 创建Servers列表并将其绑定到第一个列表框。 然后将其他两个列表框绑定到第一个列表框的当前选定项目。 最终结果可能如下所示：

serverListBox.ItemSource = Servers;
domainListBox.ItemSource = (serverListBox.SelectedItem as Server).Domains;
csrListBox.ItemSource = (serverListBox.SelectedItem as Server).Csrs;

这使您能够设置不同的“列表框”数据，而无需编写很多可能使其无法维护的代码。

Answer 2

如果您从服务器列表框中选择服务器，则可以删除这样的关联项（假装有一些删除按钮，您可以从列表框中选择域，然后单击删除按钮）：

private void removeBtn_Click(object sender, EventArgs e)
    {
        List<string> items = csrListBox.Items.Cast<string>().ToList();
        foreach (string item in csrListBox.Items)
        {
            Regex regex = new Regex(@"^" + domainListBox.SelectedItem + @"\w*");
            Match match = regex.Match(item);
            if (match.Success)
            {
                items.Remove(item);
            }
        }

        csrListBox.DataSource = items;
    }

希望能帮助到你。

Answer 3

好吧，看到您的代码，删除服务器时只需执行以下操作：

        string server = serverListBox.SelectedItem as string;
        serverListBox.Remove(server);
        for (int i = domainListBox.Items.Count -1; i >-1; i--)
        {
            if (domainListBox.Items[i].ToString().StartsWith(server))
            {
                string domain = domainListBox.Items[i].ToString();
                domainListBox.Items.RemoveAt(i);
                for (int j = csrListBox.Items.Count-1; j > -1; j--)
                {
                    if (csrListBox.Items[j].ToString().StartsWith(domain))
                    {
                        csrListBox.Items.RemoveAt(j);
                    }
                }
            }
        }

编辑我已经测试过了，应该可以

Answer 4

更好的选择是将可观察模式用作

 public class ObservableObject<T> : IList, IListSource
{

    protected BindingSource src = null;
    List<ListControl> Subscribers;
    ObservableCollection<T> Data = new ObservableCollection<T>();

    public bool IsReadOnly
    {
        get
        {
            return false;
        }
    }

    public bool IsFixedSize
    {
        get
        {
            return false;
        }
    }

    public int Count
    {
        get
        {
            return Data.Count;
        }
    }

    public object SyncRoot
    {
        get
        {
            throw new NotImplementedException();
        }
    }

    public bool IsSynchronized
    {
        get
        {
            throw new NotImplementedException();
        }
    }

    public bool ContainsListCollection
    {
        get
        {
            return true;
        }
    }

    object IList.this[int index]
    {
        get
        {
            return Data[index];
        }

        set
        {
            Data[index] = (T)value;
        }
    }

    public T this[int index]
    {
        get
        {
            return Data[index];
        }

        set
        {
            Data[index] = value;
        }
    }

    public ObservableObject()
    {
        Data.CollectionChanged += Domains_CollectionChanged;
        Subscribers = new List<ListControl>();
        src = new BindingSource();
        src.DataSource = Data;


    }
    private void Domains_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
         src.ResetBindings(false);
    }
    public virtual void Subscribe(ListBox ctrl)
    {

        this.Subscribers.Add(ctrl);
        //ctrl.DataBindings.Add(new Binding("SelectedValue", src, "Name",
        //                    true, DataSourceUpdateMode.Never));
        ctrl.DataSource = src;
    }

    public int Add(object value)
    {
        Data.Add((T)value);
        return Data.Count - 1;
    }

    public bool Contains(object value)
    {
        return Data.Contains((T)value);
    }

    public void Clear()
    {
        Data.Clear();
    }

    public int IndexOf(object value)
    {
        return Data.IndexOf((T)value);
    }

    public void Insert(int index, object value)
    {
        Data.Insert(index, (T)value);
    }

    public void Remove(object value)
    {
        Data.Remove((T)value);
    }

    public void RemoveAt(int index)
    {
        Data.RemoveAt(index);
    }

    public void CopyTo(Array array, int index)
    {
        throw new NotImplementedException();
    }

    public IEnumerator GetEnumerator()
    {
        return Data.GetEnumerator();
    }

    public IList GetList()
    {
        return Data;
    }
}

public class BaseModel : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            this._name = value;

            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs("Name"));
            }
        }
    }
}

public class CSR : BaseModel
{

    public override string ToString()
    {
        return Name;
    }


}
public class Domain : BaseModel
{
    public ObservableObject<CSR> CSRs { get; set; }


    public Domain()
    {
        CSRs = new ObservableObject<CSR>();
    }
    public override string ToString()
    {
        return Name;
    }

}
public class Server : BaseModel
{

    public ObservableObject<Domain> Domains { get; set; }

    public Server()
    {
        Domains = new ObservableObject<Domain>();
    }
    public override string ToString()
    {
        return Name;
    }


}
public class DataModel : BaseModel
{
    public ObservableObject<Server> Servers
    {
        get; set;
    }
    public DataModel()
    {
        Servers = new ObservableObject<Server>();
    }
    public override string ToString()
    {
        return Name;
    }


}

在表格上

     DataModel m = new DataModel();
    public Form1()
    {
       ...
        m.Servers.Subscribe(listBox1);
    }
 private void listBox2_Click(object sender, EventArgs e)
    {
        if (listBox2.SelectedIndex >= 0)
        {
            m.Servers[listBox1.SelectedIndex].Domains[listBox2.SelectedIndex].CSRs.Subscribe(listBox3);

        }
    }

    private void listBox1_Click(object sender, EventArgs e)
    {
        if (listBox1.SelectedIndex >= 0)
        {
            m.Servers[listBox1.SelectedIndex].Domains.Subscribe(listBox2);

        }
    }

您无需编写代码即可从此角度从表单中删除项目。从模型中删除对象