1

あるコレクションを別のコレクションにバインドしたいだけです。

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

そしてあります

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

したがって、拡張されたアイテムは元のアイテムとまったく同じですが、最後に「_extension」が付いています。

私が欲しいのは、拡張されたものをオリジナルにバインドして、オリジナルが変更された場合に拡張されたものも変更されるようにすることです。

イベントを使用して、毎回拡張機能を再作成できることはわかっています。しかし、これは効率的ではないと思います。

編集：言いましょう：オリジナルは大きく、拡張された単一の要素を再作成するには疲れすぎており、単一の要素を作成するには疲れすぎています。したがって、2つのリスト（またはコレクション）が必要です。ここで、onはもう一方を監視し、Wpfのデータバインディングのように変更を追加または削除しますが、拡張機能を追加します。

4

3 に答える 3

1

System.ComponentModelのクラスを使用してBindingList<T>これを実現できます...おそらくハンマーでハエを殺すようなものですが、より複雑な例に役立ちます。

次のような拡張メソッドを作成できると思います。

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

そして、これをすべてで使用できますIEnumerable<String>：

foreach (var x in original.Extensions())
{
    Console.WriteLine(x);
}
于 2012-11-07T09:01:33.797 に答える
0

次の 2 つの異なるアプローチがあると思います。

  1. 元が変わったら変えるextended。
  2. まったく作成するのではなくextended、すべてのクエリに「_extention」を追加するクラスを作成します。

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;
        }
    }
}

2 番目のアプローチは次のようになります。独自のクラス witch を作成します。originals

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();
            }
        }
    }
}
于 2012-11-07T09:07:17.697 に答える
-1

独自のクラスを作成します。

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
                            }
                           );
于 2012-11-07T08:45:49.733 に答える