Adds an item to the back of the Deque. The indices of all existing items in the Deque are unchanged. This method is equivalent to AddToBack(item).

Adds a collection of items to the back of the Deque. The indices of all existing items in the Deque are unchanged. The last item in the added collection becomes the last item in the Deque.

Adds a collection of items to the front of the Deque. The indices of all existing items in the Deque are increased by the number of items inserted. The first item in the added collection becomes the first item in the Deque.

Adds an item to the back of the Deque. The indices of all existing items in the Deque are unchanged. This method is equivalent to Insert(Count, item) but is a little more efficient.

Adds an item to the front of the Deque. The indices of all existing items in the Deque are increased by 1. This method is equivalent to Insert(0, item) but is a little more efficient.

Provides a read-only view of this list. The returned IList<T> provides a view of the list that prevents modifications to the list. Use the method to provide access to the list without allowing changes. Since the returned object is just a view, changes to the list will be reflected in the view.

Removes all items from the Deque.

Creates a new Deque that is a copy of this one.

Makes a deep clone of this Deque. A new Deque is created with a clone of each element of this set, by calling ICloneable.Clone on each element. If T is a value type, then each element is copied as if by simple assignment.

Determines if the list contains any item that compares equal to item. The implementation simply checks whether IndexOf(item) returns a non-negative value.

Convert this collection of items by applying a delegate to each item in the collection. The resulting enumeration contains the result of applying converter to each item in this collection, in order.

Copies all the items in the list, in order, to array, starting at index 0.

Copies all the items in the Deque into an array.

Copies a range of elements from the list to array, starting at arrayIndex.

Counts the number of items in the collection that satisfy the condition defined by predicate.

Determines if the collection contains any item that satisfies the condition defined by predicate.

Finds the first item in the list that satisfies the condition defined by predicate. If no item matches the condition, than the default value for T (null or all-zero) is returned.

Enumerates the items in the collection that satisfy the condition defined by predicate.

Finds the index of the first item in the list that satisfies the condition defined by predicate. If no item matches the condition, -1 is returned.

Finds the index of the first item, in the range of items extending from index to the end, that satisfies the condition defined by predicate. If no item matches the condition, -1 is returned.

Finds the index of the first item, in the range of count items starting from index, that satisfies the condition defined by predicate. If no item matches the condition, -1 is returned.

Finds the last item in the list that satisfies the condition defined by predicate. If no item matches the condition, than the default value for T (null or all-zero) is returned.

Finds the index of the last item in the list that satisfies the condition defined by predicate. If no item matches the condition, -1 is returned.

Finds the index of the last item, in the range of items extending from the beginning of the list to index, that satisfies the condition defined by predicate. If no item matches the condition, -1 is returned.

Finds the index of the last item, in the range of count items ending at index, that satisfies the condition defined by predicate. If no item matches the condition, -1 is returned.

Performs the specified action on each item in this collection.

Retreives the item currently at the back of the Deque. The Deque is unchanged. This method is equivalent to deque[deque.Count - 1] (except that a different exception is thrown).

Retreives the item currently at the front of the Deque. The Deque is unchanged. This method is equivalent to deque[0] (except that a different exception is thrown).

Enumerates all of the items in the list, in order. The item at index 0 is enumerated first, then the item at index 1, and so on. If the items are added to or removed from the Deque during enumeration, the enumeration ends with an InvalidOperationException.

Finds the index of the first item in the list that is equal to item.

Finds the index of the first item, in the range of items extending from index to the end, that is equal to item.

Finds the index of the first item, in the range of count items starting from index, that is equal to item.

Inserts a new item at the given index in the Deque. All items at indexes equal to or greater than index move up one index in the Deque.

Inserts a collection of items at the given index in the Deque. All items at indexes equal to or greater than index increase their indices in the Deque by the number of items inserted.

Finds the index of the last item in the list that is equal to item.

Finds the index of the last item, in the range of items extending from the beginning of the list to index, that is equal to item.

Finds the index of the last item, in the range of count items ending at index, that is equal to item.

Returns a view onto a sub-range of this list. Items are not copied; the returned IList<T> is simply a different view onto the same underlying items. Changes to this list are reflected in the view, and vice versa. Insertions and deletions in the view change the size of the view, but insertions and deletions in the underlying list do not.

Searches the list for the first item that compares equal to item. If one is found, it is removed. Otherwise, the list is unchanged.

Removes all the items in the collection that satisfy the condition defined by predicate.

Removes the item at the given index in the Deque. All items at indexes greater than index move down one index in the Deque.

Removes an item from the back of the Deque. The indices of all existing items in the Deque are unchanged. This method is equivalent to RemoveAt(Count-1) but is a little more efficient.

Removes an item from the front of the Deque. The indices of all existing items in the Deque are decreased by 1. This method is equivalent to RemoveAt(0) but is a little more efficient.

Removes a range of items at the given index in the Deque. All items at indexes greater than index move down count indices in the Deque.

Creates an array of the correct size, and copies all the items in the collection into the array, by calling CopyTo.

Shows the string representation of the collection. The string representation contains a list of the items in the collection. Contained collections (except string) are expanded recursively.

Trims the amount of memory used by the Deque by changing the Capacity to be equal to Count. If no more items will be added to the Deque, calling TrimToSize will reduce the amount of memory used by the Deque.

Determines if all of the items in the collection satisfy the condition defined by predicate.

Finds the first item in the list that satisfies the condition defined by predicate.

Finds the last item in the list that satisfies the condition defined by predicate.