삽입 순서를 유지하는 콜렉션을 설정하십시오.

Question

세트로 작동하고 요소 삽입 순서를 유지하는 콜렉션이 필요합니다.

직접 구현해야합니까? 아니면 직접 구현해야합니까?

최상의 구현 방법은 무엇입니까?

Answer 1

.NET에는 존재하지 않지만 List 및 Distinct LINQ 확장 메서드를 사용하여 에뮬레이션 할 수 있습니다.이 메서드는 기본이되는 List의 순서를 유지해야합니다.

Answer 2

OrderedDictionary으로 원하는 작업을 수행 할 수 있습니까?

일반적인 것은 아니지만 (반환되는 모든 것은 캐스트되거나 언 박싱되어야 함) 사전 (집합이 아닌)이므로 원하는대로 작동합니다. null 또는 true과 같은 임의의 값을 값으로 사용하고 키를 세트의 구성원으로 사용할 수 있습니다.

여기 가능한 구현의 :

public class OrderedSet : ICollection, IEnumerable 
{ 
    OrderedDictionary dict = new OrderedDictionary(); 
    public void Add(object member) 
    { 
     dict.Add(member, null); 
    } 
    public void Clear() 
    { 
     dict.Clear(); 
    } 
    public void CopyTo(Array array, int index) 
    { 
     for (int i = 0; i < Count; i++) 
      array[i + index] = dict[i]; 
    } 
    public bool Contains(object member) 
    { 
     return dict.Contains(member); 
    } 
    public void Insert(int index, object member) 
    { 
     dict.Insert(index, member, null); 
    } 
    public void Remove(object member) 
    { 
     dict.Remove(member); 
    } 
    public void RemoveAt(int index) 
    { 
     dict.RemoveAt(index); 
    } 
    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return dict.Keys.GetEnumerator(); 
    } 

    public int Count { get { return dict.Count; } } 
    public ICollection Members { get { return dict.Keys; } } 
    bool ICollection.IsSynchronized { get { return dict.IsSynchronized; } } 
    object ICollection.SyncRoot { get { return dict.SyncRoot; } } 
} 

Answer 3

목록 inCountryList = 새로운 ArrayList를(); . . . Set countrySet = 새 LinkedHashSet (inCountryList);

LinkedHashSet은 삽입 순서를 유지하지 않고 복제를 허용하지 않습니다.

Answer 4

그것은 하나를 쉽게 만들 수 있습니다 :

public class InsertionOrderSet<T> : KeyedCollection<T,T> 
{ 
    protected override T GetKeyForItem(T item) 
    { 
     return item; 
    } 
} 

주의 할 : .Add(T)를 통해 중복 항목을 삽입하는 것은 바로이 경우에 false을 반환하는 HashSet<T>, 말, 다르다 ArgumentException의, 발생합니다.

Answer 5

나는 이것이 오래된 게시물이라는 것을 알고 있지만, 최근 비슷한 비슷한 것을 필요로했다. 누군가가 주문 항목을 유지 관리하는 일반적인 시퀀스를 원한다면이 구현이 도움이된다고 생각했다. 주어진 항목 이후). 나는 누군가가 이것을 할 수있는보다 효율적인 방법을 가지고 있다고 확신하지만, 이것은 속임수입니다.

public class Sequence<T> : ICollection<T> 
{ 
    private readonly SortedList<long, T> _baseList; 

    public Sequence() 
    { 
     this._baseList = new SortedList<long, T>(); 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     return this._baseList.Values.GetEnumerator(); 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return this.GetEnumerator(); 
    } 

    public void Add(T item) 
    { 
     this._baseList.Add(this._baseList.Count(), item); 
    } 

    public void AddAfter(T item, T newItem) 
    { 
     var currentIndex = this._baseList.IndexOfValue(item); 
     if (currentIndex == _baseList.Count()) 
     { 
      this.Add(newItem); 
     } 
     else 
     { 
      var itemsToMove = new SortedList<long, T>(); 
      var total = Count; 
      for (var i = currentIndex + 1; i < total; i++) 
      { 
       itemsToMove.Add(i, _baseList[i]); 
       _baseList.Remove(i); 
      } 

      this.Add(newItem); 
      foreach (var itemToMove in itemsToMove) 
      { 
       this.Add(itemToMove.Value); 
      } 
     } 
    } 

    public void AddBefore(T item, T newItem) 
    { 
     var currentIndex = this._baseList.IndexOfValue(item); 
     var itemsToMove = new SortedList<long, T>(); 
     var total = Count; 
     for (var i = currentIndex; i < total; i++) 
     { 
      itemsToMove.Add(i, this._baseList[i]); 
      _baseList.Remove(i); 
     } 

     this.Add(newItem); 
     foreach (var itemToMove in itemsToMove.Values) 
     { 
      this.Add(itemToMove); 
     } 
    } 

    public void Clear() 
    { 
     this._baseList.Clear(); 
    } 

    public bool Contains(T item) 
    { 
     return this._baseList.ContainsValue(item); 
    } 

    public void CopyTo(T[] array, int arrayIndex) 
    { 
     this._baseList.Values.CopyTo(array, arrayIndex); 
    } 

    public bool Remove(T item) 
    { 
     try 
     { 
      this._baseList.RemoveAt(this._baseList.IndexOfValue(item)); 
      return true; 
     } 
     catch 
     { 
      return false; 
     } 
    } 

    public int Count 
    { 
     get 
     { 
      return this._baseList.Count(); 
     } 
    } 

    public bool IsReadOnly 
    { 
     get 
     { 
      return false; 
     } 
    } 
}