C# 集合的数据绑定

我只想将一个集合绑定到另一个集合： 假设有一个

List<string> original = new List<string>();

还有一个

List<string> extended = 
           new List<string>(from curItem in originals select curItem + "_extension");

因此，扩展的项与原始项相同，但在末尾有一个_扩展

我想要的是将扩展绑定到原始，这样，如果原始更改，扩展也会更改

我知道每次我都可以使用事件并重新创建扩展。 但我认为这是没有效率的

编辑： 比如说：原始文件很大，要重新创建扩展文件的单个元素太费劲了，创建单个元素也太费劲了。 因此，我希望有两个列表或集合，其中on观察另一个列表或集合并添加或删除更改，如Wpf中的数据绑定，但添加一个扩展。

创建自己的类：

public class MyClass
{
   private string _Item;
   public string Item 
   { 
       get { return _Item; }
       set 
       {
           if (_Item != value)
           {
               _Item = value;
               _ItemWithExtension = _Item + "_extension";
           }
       }
   }
   private string _ItemWithExtension;
   public string ItemWithExtension
   {
      get { return _ItemWithExtension; }
   }
}

var extended = 
           new List<MyClass>(from curItem in originals select 
                            new MyClass()
                            {
                                Item = curItem
                            }
                           );

您可以使用System.ComponentModel上的类来实现此功能。。。也许这就像用锤子打死一只苍蝇，但会有更复杂的例子

我想你可以这样做一个扩展方法：

static class ExtensionMethods
{
    public static IEnumerable<string> Extensions(this IEnumerable<string> strs)
    {
        foreach (var str in strs)
        {
            yield return str + "_extension";
        }
    }
}

---

我认为有两种不同的方法：

当原始更改时更改扩展。 根本不创建扩展类，而是创建一些类，这将 在每个查询上添加扩展名。 使用bindingList，第一种方法将足够有效

public class MyClass
{
    private BindingList<string> original = new BindingList<string>();
    private List<string> extended = new List<string>();

    public BindingList<string> Original
    {
        get
        {
            return original;
        }
    }

    public IEnumerable<string> Extended
    {
        get
        {
            return extended;
        }
    }

    public MyClass()
    {
        original.ListChanged += OnChanging;
    }

    void OnChanging(object sender, ListChangedEventArgs e)
    {
        switch (e.ListChangedType)
        {
            case ListChangedType.ItemAdded:
                extended.Add(original[e.NewIndex] + "_extention");
                break;
            case ListChangedType.ItemChanged:
                extended[e.NewIndex] = original[e.NewIndex] + "_extention";
                break;
            case ListChangedType.ItemDeleted:
                extended.RemoveAt(e.NewIndex);
                break;
            case ListChangedType.ItemMoved:
                string tmp = extended[e.NewIndex];
                extended[e.NewIndex] = extended[e.OldIndex];
                extended[e.OldIndex] = tmp;
                break;
            case ListChangedType.Reset:
                extended = new List<string>();
                foreach (string originalItem in original)
                {
                    extended.Add(originalItem + "_extention");
                }
                break;
        }
    }
}

---

更改原始项对扩展项有何影响？@Amiram Korach:您的解决方案的问题是，每次访问新项时，新项都会被重新创建。但我觉得这也让人筋疲力尽。我希望扩展后的项目能够观察原始项目并及时添加新项目。@阿米拉姆：如果我扩展了[0]，该怎么办？ItemWithExtension？我将得到*\u分机_extension@DmitryDovgopoly，当您更改项目时，带有扩展名的项目将被更改，但我会改进我的答案。@Amiram Korach但我认为，扩展名不会更新，如果原始项发生更改…请检查返回电流；行中，我想它应该是returncurrentstring。bindingslist可能是我正在寻找的东西：它提供了报告更改的方法。但是我仍然需要为扩展类创建自己的列表类扩展，它可以处理这些更改。有没有什么已经实现了呢？看一看，检查这个：谢谢，但也许我会使用ObservableCollection。另一方面，我不需要扩展扩展的List类，因为我需要一个处理更改内容的方法。。。

public class MyClass
{
    private BindingList<string> original = new BindingList<string>();
    private List<string> extended = new List<string>();

    public BindingList<string> Original
    {
        get
        {
            return original;
        }
    }

    public IEnumerable<string> Extended
    {
        get
        {
            return extended;
        }
    }

    public MyClass()
    {
        original.ListChanged += OnChanging;
    }

    void OnChanging(object sender, ListChangedEventArgs e)
    {
        switch (e.ListChangedType)
        {
            case ListChangedType.ItemAdded:
                extended.Add(original[e.NewIndex] + "_extention");
                break;
            case ListChangedType.ItemChanged:
                extended[e.NewIndex] = original[e.NewIndex] + "_extention";
                break;
            case ListChangedType.ItemDeleted:
                extended.RemoveAt(e.NewIndex);
                break;
            case ListChangedType.ItemMoved:
                string tmp = extended[e.NewIndex];
                extended[e.NewIndex] = extended[e.OldIndex];
                extended[e.OldIndex] = tmp;
                break;
            case ListChangedType.Reset:
                extended = new List<string>();
                foreach (string originalItem in original)
                {
                    extended.Add(originalItem + "_extention");
                }
                break;
        }
    }
}

public class MyExtendedList : IEnumerable
{
    private List<string> original;
    public MyExtendedList(List<String> original)
    {
        this.original = original;
    }

    public IEnumerator GetEnumerator()
    {
        return new ExtendedEnum(original);
    }
}

public class ExtendedEnum : IEnumerator
{
    private List<string> original;
    private int position = -1;
    public ExtendedEnum(List<String> original)
    {
        this.original = original;
    }

    public object Current
    {
        get
        {
            return CurrentString;
        }
    }

    public bool MoveNext()
    {
        position++;
        return (position < original.Count);
    }

    public void Reset()
    {
        position = -1;
    }

    public String CurrentString
    {
        get
        {
            try
            {
                return original[position] + "_extension";
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
}