<Type Name="List&lt;T&gt;" FullName="System.Collections.Generic.List&lt;T&gt;">
  <TypeSignature Language="C#" Value="public class List&lt;T&gt; : System.Collections.Generic.ICollection&lt;T&gt;, System.Collections.Generic.IEnumerable&lt;T&gt;, System.Collections.Generic.IList&lt;T&gt;, System.Collections.IList" />
  <AssemblyInfo>
    <AssemblyName>mscorlib</AssemblyName>
    <AssemblyVersion>2.0.0.0</AssemblyVersion>
  </AssemblyInfo>
  <TypeParameters>
    <TypeParameter Name="T" />
  </TypeParameters>
  <Base>
    <BaseTypeName>System.Object</BaseTypeName>
  </Base>
  <Interfaces>
    <Interface>
      <InterfaceName>System.Collections.Generic.ICollection&lt;T&gt;</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.Collections.Generic.IEnumerable&lt;T&gt;</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.Collections.Generic.IList&lt;T&gt;</InterfaceName>
    </Interface>
    <Interface>
      <InterfaceName>System.Collections.IList</InterfaceName>
    </Interface>
  </Interfaces>
  <Docs>
    <typeparam name="T">To be added.</typeparam>
    <summary>
      <para>Implements the <see cref="T:System.Collections.Generic.IList&lt;T&gt;" /> interface. The size of a List is dynamically increased as required. A List is not guaranteed to be sorted. It is the programmer's responsibility to sort the List prior to performing operations (such as <see langword="BinarySearch" />) that require a List to be sorted. Indexing operations are required to perform in constant access time; that is, O(1).</para>
    </summary>
    <remarks>
      <para>Some methods, such as <see langword="Contains" />, <see langword="IndexOf" />, <see langword="LastIndexOf" />, and <see langword="Remove" />, use an equality comparer for the list elements.  The default equality comparer for type T is determined as follows:  If type T implements <see cref="T:System.IEquatable&lt;T&gt;" /> then the default equality comparer is <see cref="M:System.IEquatable;T&gt;.Equals" /><see langword="(T)" />; otherwise the default equality comparer is <see cref="M:System.Object.Equals" /><see langword="(Object)" />.</para>
      <para>Some methods, such as <see langword="BinarySearch" /> and <see langword="Sort" />, use a comparer for the list elements.  Some overloads of these methods take an explicit comparer as argument, while others use a default comparer.  The default comparer for type T is determined as follows:  If type T implements <see cref="I:System.IComparable&lt;T&gt;" /> then the default comparer is <see cref="M:System.IComparable&lt;T&gt;.CompareTo" /><see langword="(T)" />; otherwise, if type T implements <see cref="T:System.IComparable" /> then the default comparer is <see cref="M:System.IComparable.CompareTo" /><see langword="(Object)" />.  If type T implements neither <see cref="T:System.IComparable&lt;T&gt;" /> nor <see cref="T:System.IComparable" />  then there is no default comparer; in this case a comparer or comparison delegate must be given explicitly.</para>
      <para>The capacity of a <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> is the number of elements the <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> can hold. As elements are added to a <see cref="T:System.Collections.Generic.List&lt;T&gt;" />, the capacity is automatically increased as required.. The capacity can be decreased by calling <see cref="M:System.Collections.Generic.List&lt;T&gt;.TrimToSize" /> or by setting the <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" /> property explicitly.</para>
      <para>Indexes in this collection are zero-based.</para>
      <para>
        <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> accepts <see langword="null" /> as a valid value for reference types and allows duplicate elements.</para>
      <para>This type contains a member that is a nested type, called <see langword="Enumerator" />. Although <see langword="Enumerator" /> is a member of this type, <see langword="Enumerator" /> is not described here; instead, it is described in its own entry, <see langword="List&lt;T&gt;.Enumerator" />.</para>
    </remarks>
    <since version=".NET 2.0" />
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public List ();" />
      <MemberType>Constructor</MemberType>
      <Parameters />
      <Docs>
        <summary>
          <para>Initializes a new list that is empty and has the default initial capacity.</para>
        </summary>
        <remarks>
          <para>
            <block subset="none" type="note">If the size of the collection can be estimated, you can specify the initial capacity in a constructor overload that accepts a capacity parameter to eliminate the need to perform a number of resizing operations while adding elements to the list.</block>
          </para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public List (System.Collections.Generic.IEnumerable&lt;T&gt; collection);" />
      <MemberType>Constructor</MemberType>
      <Parameters>
        <Parameter Name="collection" Type="System.Collections.Generic.IEnumerable&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="collection">The collection from which to copy the elements.</param>
        <summary>
          <para>Initializes a new list with elements copied from the specified collection, ensuring that the list has sufficient capacity to accommodate the number of elements copied.</para>
        </summary>
        <remarks>
          <para>
            <block subset="none" type="note">If the size of the collection can be estimated, you can specify the initial capacity in a constructor overload that accepts a capacity parameter to eliminate the need to perform a number of resizing operations while adding elements to the list.</block>
          </para>
          <para>The elements are copied onto the list in the same order in which they are read by the System.Collections.Generic.IEnumerator&lt;T&gt; from collection.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <paramref name="collection" /> is <see langword="null" />.</exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public List (int capacity);" />
      <MemberType>Constructor</MemberType>
      <Parameters>
        <Parameter Name="capacity" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="capacity">The maximum number of elements that the List can contain without reallocating memory.</param>
        <summary>
          <para>Initializes a new list that is empty and has the specified initial capacity.</para>
        </summary>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <paramref name="capacity" /> is less than zero.</exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Add">
      <MemberSignature Language="C#" Value="public void Add (T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="item">The item to add to the end of the list. (<paramref name="item" /> can be <see langword="null" /> if T is a reference type.)</param>
        <summary>
          <para>Adds an item to the end of the list.</para>
        </summary>
        <remarks>
          <para>
            <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> accepts <see cref="null" /> as a valid value for reference types and allows duplicate elements.</para>
          <para>If <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> already equals <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" />, the capacity of the list is increased.</para>
          <para>If <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> is less than <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" />, this method is an O(1) operation. If the capacity needs to be increased to accommodate the new element, this method becomes an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="AddRange">
      <MemberSignature Language="C#" Value="public void AddRange (System.Collections.Generic.IEnumerable&lt;T&gt; collection);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="collection" Type="System.Collections.Generic.IEnumerable&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="collection">The collection whose elements are added to the end of the list.</param>
        <summary>
          <para>Adds the elements of the specified collection to the end of the list.</para>
        </summary>
        <remarks>
          <para>
            <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> accepts <see langword="null" /> as a valid value for reference types and allows duplicate elements.</para>
          <para>The order of the elements in the collection is preserved in the <see cref="T:System.Collections.Generic.List&lt;T&gt;" />.</para>
          <para>If the new <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> (the current  <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> plus the size of the collection) will be greater than <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" />, the capacity of the list is increased.</para>
          <para>If the list can accommodate the new elements without increasing <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" />, this method is an O(n) operation, where n is the number of elements to be added. If the capacity needs to be increased to accommodate the new elements, this method becomes an O(n + m) operation, where n is the number of elements to be added and m is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <paramref name="collection" /> is <see langword="null" />.</exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="AsReadOnly">
      <MemberSignature Language="C#" Value="public System.Collections.ObjectModel.ReadOnlyCollection&lt;T&gt; AsReadOnly ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.ObjectModel.ReadOnlyCollection&lt;T&gt;</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Returns a read-only wrapper to the current List.</para>
        </summary>
        <returns>
          <para>A read-only wrapper for the current List.</para>
        </returns>
        <remarks>
          <para>To prevent any modifications to a list, expose it only through this wrapper.</para>
          <para>A collection that is read-only is simply a collection with a wrapper that prevents modifying the collection; therefore, if changes are made to the underlying collection, the read-only collection reflects those changes.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="BinarySearch">
      <MemberSignature Language="C#" Value="public int BinarySearch (T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="item">The element for which to search. (<paramref name="item" /> can be <see langword="null" /> if T is a reference type.)</param>
        <summary>
          <para>Searches the entire sorted list for an element using the default comparer, and returns the zero-based index of the element.</para>
        </summary>
        <returns>
          <para>The zero-based index of <paramref name="item" /> in the sorted list, if <paramref name="item" /> is found; otherwise, a negative number, which is the bitwise complement of the index of the next element that is larger than <paramref name="item" /> or, if there is no larger element, the bitwise complement of <see cref="T:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </returns>
        <remarks>
          <para>This method uses the default comparer for type T to determine the order of list elements.  If there is no default comparer, then the method throws <see cref="T:System.InvalidOperationException" />.  The default comparer for a given element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>The list must already be sorted according to the comparer implementation; otherwise, the result is incorrect.</para>
          <para>Comparing <see langword="null" /> with any reference type is allowed and does not generate an exception when using <see cref="T:System.IComparable&lt;T&gt;" />. When sorting, <see langword="null" /> is considered to be less than any other object.</para>
          <para>If the list  contains more than one element with the same value, the method returns only one of the occurrences, and it might return any one of the occurrences, not necessarily the first one.</para>
          <para>If the list does not contain the specified value, the method returns a negative integer. You can apply the bitwise complement operation (~) to this negative integer to get the index of the first element that is larger than the search value. When inserting the value into the list, this index should be used as the insertion point to maintain the sort order.</para>
          <para>This method is an O(log n) operation, where n is the number of elements in the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.InvalidOperationException">
          <para>The default comparer cannot find a <see cref="T:System.IComparable&lt;T&gt;" /> or <see cref="T:System.IComparable" /> implementation for type T.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="BinarySearch">
      <MemberSignature Language="C#" Value="public int BinarySearch (T item, System.Collections.Generic.IComparer&lt;T&gt; comparer);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
        <Parameter Name="comparer" Type="System.Collections.Generic.IComparer&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="item">The element for which to search. (<paramref name="item" /> can be <see langword="null" /> if T is a reference type.)</param>
        <param name="comparer">
          <para>The <see cref="T:System.Collections.Generic.IComparer&lt;T&gt;" />  implementation to use when comparing elements.</para>
          <para>-or-</para>
          <para>
            <see langword="null" /> to use the default comparer.</para>
        </param>
        <summary>
          <para>Searches the entire sorted list for an element using the specified comparer and returns the zero-based index of the element.</para>
        </summary>
        <returns>
          <para>The zero-based index of <paramref name="item" /> in the sorted list, if <paramref name="item" /> is found; otherwise, a negative number, which is the bitwise complement of the index of the next element that is larger than <paramref name="item" /> or, if there is no larger element, the bitwise complement of <see cref="T:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </returns>
        <remarks>
          <para>If the given comparer is non-<see langword="null" />, it is used to determine the order of list elements.  If the given comparer is <see langword="null" />, the default comparer for type T is used; if there is no default comparer, then the method throws <see cref="T:System.InvalidOperationException" />.  The default comparer for a given element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>The comparer customizes how the elements are compared. For example, if T is <see cref="T:System.String" />, you can use a <see cref="T:System.Collections.CaseInsensitiveComparer" /> instance as the comparer to perform case-insensitive string searches.</para>
          <para>The list must already be sorted according to the comparer implementation; otherwise, the result is incorrect.</para>
          <para>Comparing <see langword="null" /> with any reference type is allowed and does not generate an exception when using <see cref="T:System.IComparable&lt;T&gt;" />. When sorting, <see langword="null" /> is considered to be less than any other object.</para>
          <para>If the <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> contains more than one element with the same value, the method returns only one of the occurrences, and it might return any one of the occurrences, not necessarily the first one.</para>
          <para>If the list does not contain the specified value, the method returns a negative integer. You can apply the bitwise complement operation (~) to this negative integer to get the index of the first element that is larger than the search value. When inserting the value into the list, this index should be used as the insertion point to maintain the sort order.</para>
          <para>This method is an O(log n) operation, where n is the number of elements in the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.InvalidOperationException">
          <para>
            <paramref name="comparer" /> is <see langword="null" />, and the default comparer cannot find a <see cref="T:System.IComparable&lt;T&gt;" /> or<see cref="T:System.IComparable" /> implementation for type T.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="BinarySearch">
      <MemberSignature Language="C#" Value="public int BinarySearch (int index, int count, T item, System.Collections.Generic.IComparer&lt;T&gt; comparer);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
        <Parameter Name="item" Type="T" />
        <Parameter Name="comparer" Type="System.Collections.Generic.IComparer&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based starting index of the range to search.</param>
        <param name="count">The length of the range to search.</param>
        <param name="item">The element for which to search. (<paramref name="item" /> can be <see langword="null" /> if T is a reference type.)</param>
        <param name="comparer">
          <para>The <see cref="T:System.Collections.Generic.IComparer&lt;T&gt;" />  implementation to use when comparing elements.</para>
          <para>-or-</para>
          <para>
            <see langword="null" /> to use the default comparer.</para>
        </param>
        <summary>
          <para>Searches a range of elements in the sorted list for an element using the specified comparer and returns the zero-based index of the element.</para>
        </summary>
        <returns>
          <para>The zero-based index of <paramref name="item" /> in the sorted list, if <paramref name="item" /> is found; otherwise, a negative number, which is the bitwise complement of the index of the next element that is larger than <paramref name="item" /> or, if there is no larger element, the bitwise complement of <paramref name="index" /> + <paramref name="count" />.</para>
        </returns>
        <remarks>
          <para>If the given comparer is non-<see langword="null" />, it is used to determine the order of list elements.  If the given comparer is <see langword="null" />, the default comparer for type T is used; if there is no default comparer, then the method throws <see cref="T:System.InvalidOperationException" />.  The default comparer for a given element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>The comparer customizes how the elements are compared. For example, if T is <see cref="T:System.String" />, you can use a <see cref="T:System.Collections.CaseInsensitiveComparer" /> instance as the comparer to perform case-insensitive string searches.</para>
          <para>The list must already be sorted according to the comparer implementation; otherwise, the result is incorrect.</para>
          <para>Comparing <see langword="null" /> with any reference type is allowed and does not generate an exception when using <see cref="T:System.IComparable&lt;T&gt;" />. When sorting, <see langword="null" /> is considered to be less than any other object.</para>
          <para>If the <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> contains more than one element with the same value, the method returns only one of the occurrences, and it might return any one of the occurrences, not necessarily the first one.</para>
          <para>If the list does not contain the specified value, the method returns a negative integer. You can apply the bitwise complement operation (~) to this negative integer to get the index of the first element that is larger than the search value. When inserting the value into the list, this index should be used as the insertion point to maintain the sort order.</para>
          <para>This method is an O(log n) operation, where n is the number of elements in the range.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than zero.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>
            <paramref name="comparer" /> is <see langword="null" />, and the default comparer cannot find a <see cref="T:System.IComparable&lt;T&gt;" /> or<see cref="T:System.IComparable" /> implementation for type T.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Capacity">
      <MemberSignature Language="C#" Value="public int Capacity { set; get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>Gets or sets the number of elements the current instance can contain.</para>
        </summary>
        <value>
          <para> A <see cref="T:System.Int32" /> containing the number of elements the current instance can contain.</para>
        </value>
        <remarks>
          <para>This property is read/write.</para>
          <para>
            <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" /> is the number of elements that the list is capable of storing without needing to be extended. <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> is the number of elements that are actually in the list.</para>
          <para>
            <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" /> is always greater than or equal to <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />. When <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> exceeds <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" /> while adding elements, the capacity is increased.</para>
          <para>The capacity can be decreased by calling <see cref="M:System.Collections.Generic.List&lt;T&gt;.TrimToSize" /> or by setting the <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" /> property explicitly.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">Attempt to set the capacity to a value less than  <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Clear">
      <MemberSignature Language="C#" Value="public void Clear ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Removes all elements from the list.</para>
        </summary>
        <remarks>
          <para>
            <see cref="P:System.Collections.Generic.ICollection&lt;T&gt;.Count" /> gets set to zero, and references to other objects from elements of the collection are also released. The capacity remains unchanged.</para>
          <para>
            <block subset="none" type="note">
              <para>To reset the capacity, call <see cref="M:System.Collections.Generic.List&lt;T&gt;.TrimToSize" /> or set the <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" /> property directly.</para>
            </block>
          </para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Contains">
      <MemberSignature Language="C#" Value="public bool Contains (T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="item">The object to locate in the current collection. (<paramref name="item" /> can be <see langword="null" /> if T is a reference type.)</param>
        <summary>
          <para>Determines whether the list contains a specific value.</para>
        </summary>
        <returns>
          <para>
            <see langword="true" />, if <paramref name="item" /> is found in the list; otherwise, <see langword="false" />.</para>
        </returns>
        <remarks>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.    The default equality comparer for element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="ConvertAll&lt;TOutput&gt;">
      <MemberSignature Language="C#" Value="public System.Collections.Generic.List&lt;TOutput&gt; ConvertAll&lt;TOutput&gt; (Converter&lt;T,TOutput&gt; converter);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.Generic.List&lt;TOutput&gt;</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="converter" Type="System.Converter&lt;T,TOutput&gt;" />
      </Parameters>
      <Docs>
        <typeparam name="TOutput">To be added.</typeparam>
        <param name="converter">To be added.</param>
        <summary>To be added.</summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
      <TypeParameters>
        <TypeParameter Name="TOutput" />
      </TypeParameters>
    </Member>
    <Member MemberName="CopyTo">
      <MemberSignature Language="C#" Value="public void CopyTo (T[] array);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="array" Type="T[]" />
      </Parameters>
      <Docs>
        <param name="array">A one-dimensional, zero-based array that is the destination of the elements copied from the list.</param>
        <summary>
          <para>Copies the entire list to an array.</para>
        </summary>
        <remarks>
          <para>The elements are copied onto the array (using <see cref="M:System.Array.Copy" />) in the same order in which the enumerator iterates through the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <para>
            <paramref name="array" /> is multidimensional.</para>
          <para>-or-</para>
          <para>
            <paramref name="array" /> does not have zero-based indexing.</para>
          <para>-or-</para>
          <para>The number of elements in the list is greater than the number of elements that the destination <paramref name="array" /> can contain.</para>
          <para>-or-</para>
          <para>Type T is not assignable to the element type of the destination array.</para>
        </exception>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="array" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="CopyTo">
      <MemberSignature Language="C#" Value="public void CopyTo (T[] array, int arrayIndex);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="array" Type="T[]" />
        <Parameter Name="arrayIndex" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="array">A one-dimensional, zero-based array that is the destination of the elements copied from the list.</param>
        <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
        <summary>
          <para>Copies the elements of the list to an array, starting at a particular index.</para>
        </summary>
        <remarks>
          <para>The elements are copied onto the array (using <see cref="M:System.Array.Copy" />) in the same order in which the enumerator iterates through the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <para>
            <paramref name="array" /> is multidimensional.</para>
          <para>-or-</para>
          <para>
            <paramref name="array" /> does not have zero-based indexing.</para>
          <para>-or-</para>
          <para>The sum of <paramref name="arrayIndex" /> and number of elements in the list is greater than the length of the destination array.</para>
          <para>-or-</para>
          <para>Type T is not assignable to the element type of the destination array.</para>
        </exception>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="array" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="arrayIndex" /> is less than zero.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="CopyTo">
      <MemberSignature Language="C#" Value="public void CopyTo (int index, T[] array, int arrayIndex, int count);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="array" Type="T[]" />
        <Parameter Name="arrayIndex" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based index in the source list at which copying begins.</param>
        <param name="array">A one-dimensional, zero-based array that is the destination of the elements copied from the list.</param>
        <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
        <param name="count">
          <para>The number of elements to copy.</para>
        </param>
        <summary>
          <para>Copies a range of elements of the list to an array, starting at a particular index in the target array.</para>
        </summary>
        <remarks>
          <para>The elements are copied onto the array (using <see cref="M:System.Array.Copy" />) in the same order in which the enumerator iterates through the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <para>
            <paramref name="array" /> is multidimensional.</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> is equal to or greater than the <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> of the source list.</para>
          <para>-or-</para>
          <para>
            <paramref name="arrayIndex" /> is equal to or greater than the length of <paramref name="array" />.</para>
          <para>-or-</para>
          <para>The number of elements from <paramref name="index" />to the end of the source list is greater than the available space from <paramref name="arrayIndex" /> to the end of the destination <paramref name="array" />.</para>
          <para>-or-</para>
          <para>Type T is not assignable to the element type of the destination array.</para>
        </exception>
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="array" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero.</para>
          <para>-or-</para>
          <para>
            <paramref name="array" /> does not have zero-based indexing.</para>
          <para>-or-</para>
          <para>
            <paramref name="arrayIndex" /> is less than zero.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than zero.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Count">
      <MemberSignature Language="C#" Value="public int Count { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>Gets the number of elements contained in the current instance.</para>
        </summary>
        <value>
          <para>The number of elements in the current instance.</para>
        </value>
        <remarks>
          <para>This property is read-only.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Exists">
      <MemberSignature Language="C#" Value="public bool Exists (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the elements to search for.</param>
        <summary>
          <para>Determines whether the List contains elements that match the conditions defined by the specified predicate.</para>
        </summary>
        <returns>
          <para>
            <see langword="true" /> if the List contains one or more elements that match the conditions defined by the specified predicate; otherwise, <see langword="false" />.</para>
        </returns>
        <remarks>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate, and processing is stopped when a match is found.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Find">
      <MemberSignature Language="C#" Value="public T Find (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>T</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire List.</para>
        </summary>
        <returns>
          <para>The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.</para>
        </returns>
        <remarks>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate, moving forward in the List, starting with the first element and ending with the last element. Processing is stopped when a match is found.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindAll">
      <MemberSignature Language="C#" Value="public System.Collections.Generic.List&lt;T&gt; FindAll (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.Generic.List&lt;T&gt;</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the elements to search for.</param>
        <summary>
          <para>Retrieves all the elements that match the conditions defined by the specified predicate.</para>
        </summary>
        <returns>
          <para>A List containing all the elements that match the conditions defined by the specified predicate, if found; otherwise, an empty List.</para>
        </returns>
        <remarks>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the Predicate delegate, and the elements that match the conditions are saved in the returned List.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindIndex">
      <MemberSignature Language="C#" Value="public int FindIndex (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the List.</para>
        </summary>
        <returns>
          <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The List is searched forward starting at the first element and ending at the last element.</para>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindIndex">
      <MemberSignature Language="C#" Value="public int FindIndex (int startIndex, Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="startIndex" Type="System.Int32" />
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="startIndex">To be added.</param>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List that extends from the specified index to the last element.</para>
        </summary>
        <returns>
          <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The List is searched forward starting at <paramref name="index" /> and ending at the last element.</para>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0 or greater than  or equal to <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindIndex">
      <MemberSignature Language="C#" Value="public int FindIndex (int startIndex, int count, Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="startIndex" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="startIndex">To be added.</param>
        <param name="count">The number of elements to search.</param>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List that starts at the specified index and contains the specified number of elements.</para>
        </summary>
        <returns>
          <para>The zero-based index of the first occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The List is searched forward starting at <paramref name="index" /> and ending after <paramref name="count" /> elements.</para>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindLast">
      <MemberSignature Language="C#" Value="public T FindLast (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>T</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire List.</para>
        </summary>
        <returns>
          <para>The last element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.</para>
        </returns>
        <remarks>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate, moving backward in the List, starting with the last element and ending with the first element.  Processing is stopped when a match is found.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindLastIndex">
      <MemberSignature Language="C#" Value="public int FindLastIndex (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the List.</para>
        </summary>
        <returns>
          <para>The zero-based index of the last occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The List is searched backward starting at the last element and ending at the first element.</para>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindLastIndex">
      <MemberSignature Language="C#" Value="public int FindLastIndex (int startIndex, Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="startIndex" Type="System.Int32" />
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="startIndex">To be added.</param>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the List that extends from the specified index to the first element.</para>
        </summary>
        <returns>
          <para>The zero-based index of the last occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The List is searched backward starting at <paramref name="index" /> and ending at the first element.</para>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0 or greater than or equal to <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="FindLastIndex">
      <MemberSignature Language="C#" Value="public int FindLastIndex (int startIndex, int count, Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="startIndex" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="startIndex">To be added.</param>
        <param name="count">The number of elements to search.</param>
        <param name="match">The predicate delegate that specifies the element to search for.</param>
        <summary>
          <para>Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the List that starts at the specified index and contains the specified number of elements going backwards.</para>
        </summary>
        <returns>
          <para>The zero-based index of the last occurrence of an element that matches the conditions defined by <paramref name="match" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The List is searched backward starting at <paramref name="index" /> and ending after <paramref name="count" /> elements.</para>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero, or greater than or equal to <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is greater than <paramref name="index" /> + 1.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="ForEach">
      <MemberSignature Language="C#" Value="public void ForEach (Action&lt;T&gt; action);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="action" Type="System.Action&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="action">The action delegate to perform on each element of the List.</param>
        <summary>
          <para>Performs the specified action on each element of the List.</para>
        </summary>
        <remarks>
          <para>The action is a delegate  that performs an action on the object passed to it.  The elements of the current List are individually passed to the action delegate, sequentially, in index order, and on the same thread as that used to call <see langword="ForEach" />. Execution stops if the action throws an exception.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="action" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="GetEnumerator">
      <MemberSignature Language="C#" Value="public System.Collections.Generic.List&lt;T&gt;.Enumerator GetEnumerator ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.Generic.List&lt;T&gt;+Enumerator</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Returns an enumerator, in index order, that can be used to iterate over the list.</para>
        </summary>
        <returns>
          <para>An enumerator for the list.</para>
        </returns>
        <remarks>
          <para>
            <block subset="none" type="usage">For a detailed description regarding the use of an enumerator, see <see cref="T:System.Collections.Generic.IEnumerator&lt;T&gt;" />.</block>
          </para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="GetRange">
      <MemberSignature Language="C#" Value="public System.Collections.Generic.List&lt;T&gt; GetRange (int index, int count);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.Generic.List&lt;T&gt;</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based index at which the range starts.</param>
        <param name="count">The number of elements in the range.</param>
        <summary>
          <para>Creates a shallow copy of a range of elements in the current List.</para>
        </summary>
        <returns>
          <para>A shallow copy of the given range of elements in the list.</para>
        </returns>
        <remarks>
          <para>A shallow copy of a collection, or a subset of that collection, copies only the elements of the collection, whether they are reference types or value types, but it does not copy the objects that the references refer to. The references in the new collection point to the same objects as do the references in the original collection. (In contrast, a deep copy of a collection copies the elements and everything directly or indirectly referenced by those elements.)</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <para>
            <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than 0.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="IndexOf">
      <MemberSignature Language="C#" Value="public int IndexOf (T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <summary>
          <para>Searches for the specified object and returns the zero-based index of the first occurrence within the entire list.</para>
        </summary>
        <returns>
          <para>The zero-based index of the first occurrence of  <paramref name="item" /> within the List, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The list is searched forward starting at the first element and ending at the last element.</para>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method performs a linear search; therefore, the average number of comparisons is proportional to <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />. That is, this method is an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="IndexOf">
      <MemberSignature Language="C#" Value="public int IndexOf (T item, int index);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
        <Parameter Name="index" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <param name="index">The zero-based starting index of the search.</param>
        <summary>
          <para>Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the list that extends from the specified index to the last element.</para>
        </summary>
        <returns>
          <para>The zero-based index of the first occurrence of <paramref name="item" /> within the range of elements in the list, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The list is searched forward starting at <paramref name="index" /> and ending at the last element.</para>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is the number of elements from <paramref name="index" /> to the end of the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero or greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="IndexOf">
      <MemberSignature Language="C#" Value="public int IndexOf (T item, int index, int count);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <param name="index">The zero-based starting index of the search.</param>
        <param name="count">The number of elements to search.</param>
        <summary>
          <para>Searches for the specified object and returns the zero-based index of the first occurrence within the range of elements in the list that starts at the specified index and contains the specified number of elements.</para>
        </summary>
        <returns>
          <para>The zero-based index of the first occurrence of <paramref name="item" /> within the specified range of elements in the list, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The list is searched forward starting at <paramref name="index" /> and ending at <paramref name="index" /> + <paramref name="count" /> - 1, and searching at most <paramref name="count" /> terms.</para>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class  <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is <paramref name="count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Insert">
      <MemberSignature Language="C#" Value="public void Insert (int index, T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based index at which <paramref name="item" /> is to be inserted.</param>
        <param name="item">The item to insert. (<paramref name="item" /> can be <see langword="null" /> if T is a reference type.)</param>
        <summary>
          <para>Inserts an item to the List at the specified position.</para>
        </summary>
        <remarks>
          <para>
            <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> accepts <see langword="null" /> as a valid value for reference types and allows duplicate elements.</para>
          <para>If <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> already equals <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" />, the capacity of the List is increased.</para>
          <para>If <paramref name="index" /> is equal to <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />, <paramref name="item" /> is added to the end of list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="InsertRange">
      <MemberSignature Language="C#" Value="public void InsertRange (int index, System.Collections.Generic.IEnumerable&lt;T&gt; collection);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="collection" Type="System.Collections.Generic.IEnumerable&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based index at which the new elements should be inserted.</param>
        <param name="collection">The collection whose elements should be inserted into the list. (<paramref name="collection" /> itself cannot be <see langword="null" />, but the collection can contain elements that are <see langword="null" />, if type T is a reference type.)</param>
        <summary>
          <para>Inserts the elements of a collection in the List at the specified position.</para>
        </summary>
        <remarks>
          <para>
            <see cref="T:System.Collections.Generic.List&lt;T&gt;" /> accepts <see langword="null" /> as a valid value for reference types and allows duplicate elements.</para>
          <para>If the new value of <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" /> will be greater than <see cref="P:System.Collections.Generic.List&lt;T&gt;.Capacity" />, the capacity of the List is increased.</para>
          <para>If <paramref name="index" /> is equal to <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />, the collection  is added to the end of list.</para>
          <para>The order of the elements in the collection is preserved in the list.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="collection" /> is <see langword="null" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero,</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Item">
      <MemberSignature Language="C#" Value="public T this[int index] { set; get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>T</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based index of the element in the current instance to get or set.</param>
        <summary>
          <para>Gets or sets the element at the specified index of the current instance.</para>
        </summary>
        <value>
          <para>The element at the specified index of the current instance.</para>
        </value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> &lt; 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> &gt;= <see cref="P:System.Collections.Generics.List&lt;T&gt;.Count" /> of the current instance.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="LastIndexOf">
      <MemberSignature Language="C#" Value="public int LastIndexOf (T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <summary>
          <para>Searches for the specified object and returns the zero-based index of the last occurrence within the entire list.</para>
        </summary>
        <returns>
          <para>The zero-based index of the last occurrence of <paramref name="item" /> within the entire list, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The list is searched backward starting at the last element and ending at the first element.</para>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="LastIndexOf">
      <MemberSignature Language="C#" Value="public int LastIndexOf (T item, int index);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
        <Parameter Name="index" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <param name="index">The zero-based starting index of the search.</param>
        <summary>
          <para>Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the list that extends from the specified index to the last element.</para>
        </summary>
        <returns>
          <para>The zero-based index of the last occurrence of <paramref name="item" /> within the range of elements in the list, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The list is searched backward starting at <paramref name="index" /> and ending at the first element.</para>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is the number of elements from the beginning of the list to <paramref name="index" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero or greater than or equal to <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="LastIndexOf">
      <MemberSignature Language="C#" Value="public int LastIndexOf (T item, int index, int count);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <param name="index">The zero-based starting index of the search.</param>
        <param name="count">The number of elements to search.</param>
        <summary>
          <para>Searches for the specified object and returns the zero-based index of the last occurrence within the range of elements in the list that starts at the specified index and contains the specified number of elements.</para>
        </summary>
        <returns>
          <para>The zero-based index of the last occurrence of <paramref name="item" /> within the range of elements in the list that contains <paramref name="count" /> number of elements and ends at <paramref name="index" />, if found; otherwise, -1.</para>
        </returns>
        <remarks>
          <para>The list is searched backward starting at <paramref name="index" /> and ending after <paramref name="count" /> elements.</para>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is <paramref name="count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero, or greater than or equal to <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is greater than <paramref name="index" /> + 1.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Remove">
      <MemberSignature Language="C#" Value="public bool Remove (T item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="T" />
      </Parameters>
      <Docs>
        <param name="item">The object to be removed from the list.</param>
        <summary>
          <para>Removes the first occurrence of the specified object from the list.</para>
        </summary>
        <returns>
          <para>
            <see langword="true" /> if <paramref name="item" /> is successfully removed; otherwise, <see langword="false" />.</para>
        </returns>
        <remarks>
          <para>This method uses the default equality comparer for type T to determine equality of list elements.  The default equality comparer for element type T is defined in the Description section of this (class <see cref="List&lt;T&gt;" />) specification.</para>
          <para>This method is an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="RemoveAll">
      <MemberSignature Language="C#" Value="public int RemoveAll (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the elements to remove.</param>
        <summary>
          <para>Removes the all the elements that match the conditions defined by the specified predicate.</para>
        </summary>
        <returns>
          <para>The number of elements removed from the List.</para>
        </returns>
        <remarks>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate, and the elements that match the conditions are removed from the List.</para>
          <para>This method is an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="RemoveAt">
      <MemberSignature Language="C#" Value="public void RemoveAt (int index);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based index of the item to remove.</param>
        <summary>
          <para>Removes the item at the specified index of the list.</para>
        </summary>
        <remarks>
          <para>The item is removed and all the elements following it in the List have their indexes reduced by 1.</para>
          <para>This method is an O(n) operation, where n is <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than 0.</para>
          <para>-or-</para>
          <para>
            <paramref name="index" /> is equal to or greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="RemoveRange">
      <MemberSignature Language="C#" Value="public void RemoveRange (int index, int count);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based starting index of the range of elements to remove.</param>
        <param name="count">The number of elements to remove.</param>
        <summary>
          <para>Removes a range of elements from the list.</para>
        </summary>
        <remarks>
          <para>The items are removed and all the elements following them in the List have their indexes reduced by <paramref name="count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <para>
            <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than zero.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Reverse">
      <MemberSignature Language="C#" Value="public void Reverse ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Reverses the order of the elements in the list.</para>
        </summary>
        <remarks>
          <para>This method uses <see cref="M:System.Array.Reverse" /><see langword="(System.Array)" />  to reverse the order of the elements.</para>
          <para>This method is an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Reverse">
      <MemberSignature Language="C#" Value="public void Reverse (int index, int count);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based starting index of the range of elements to reverse.</param>
        <param name="count">The number of elements to reverse.</param>
        <summary>
          <para>Reverses the order of the elements in the specified element range of the list.</para>
        </summary>
        <remarks>
          <para>This method reverses the order of the elements in the specified element range</para>
          <para>This method is an O(n) operation, where n is <paramref name="count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <para>
            <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than zero.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Sort">
      <MemberSignature Language="C#" Value="public void Sort ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Sorts the elements in the list using the default comparer.</para>
        </summary>
        <remarks>
          <para>This method uses the default comparer for type T to determine the order of list elements.   If there is no default comparer, then the method throws <see cref="T:System.InvalidOperationException" />.  The default comparer for a given element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>At worst, this operation is O(n<sup>2</sup>), where n is the number of elements to sort. On average it's O(n log n).</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.InvalidOperationException">
          <para>The default comparer cannot find a <see cref="T:System.IComparable&lt;T&gt;" /> or <see cref="T:System.IComparable" /> implementation for type T.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Sort">
      <MemberSignature Language="C#" Value="public void Sort (System.Collections.Generic.IComparer&lt;T&gt; comparer);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="comparer" Type="System.Collections.Generic.IComparer&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="comparer">
          <para>The <see cref="T:System.Collections.Generic.IComparer&lt;T&gt;" />  implementation to use when comparing elements.</para>
          <para>-or-</para>
          <para>
            <see langword="null" /> to use the default comparer.</para>
        </param>
        <summary>
          <para>Sorts the elements in the list using the specified comparer.</para>
        </summary>
        <remarks>
          <para>If the given comparer is non-<see langword="null" />, it is used to determine the order of list elements.  If the given comparer is <see langword="null" />, the default comparer for type T is used; if there is no default comparer, then the method throws <see cref="T:System.InvalidOperationException" />.  The default comparer for a given element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>At worst, this operation is O(n<sup>2</sup>), where n is the number of elements to sort. On average it's O(n log n).</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.InvalidOperationException">
          <para>
            <paramref name="comparer" /> is <see langword="null" />, and the default comparer cannot find a <see cref="T:System.IComparable&lt;T&gt;" /> or <see cref="T:System.IComparable" /> implementation for type T.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Sort">
      <MemberSignature Language="C#" Value="public void Sort (Comparison&lt;T&gt; comparison);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="comparison" Type="System.Comparison&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="comparison">
          <para>The comparison to use when comparing elements.</para>
        </param>
        <summary>
          <para>Sorts the elements in the list using the specified comparison.</para>
        </summary>
        <remarks>
          <para>At worst, this operation is O(n<sup>2</sup>), where n is the number of elements to sort. On average it's O(n log n).</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <paramref name="comparison" /> is <see langword="null" />.</exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="Sort">
      <MemberSignature Language="C#" Value="public void Sort (int index, int count, System.Collections.Generic.IComparer&lt;T&gt; comparer);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="count" Type="System.Int32" />
        <Parameter Name="comparer" Type="System.Collections.Generic.IComparer&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="index">The zero-based starting index of the range of elements to sort.</param>
        <param name="count">The number of elements to sort.</param>
        <param name="comparer">
          <para>The <see cref="T:System.Collections.Generic.IComparer&lt;T&gt;" />  implementation to use when comparing elements.</para>
          <para>-or-</para>
          <para>
            <see langword="null" /> to use the default comparer.</para>
        </param>
        <summary>
          <para>Sorts the elements in the list using the specified comparer.</para>
        </summary>
        <remarks>
          <para>If the given comparer is non-<see langword="null" />, it is used to determine the order of list elements.  If the given comparer is <see langword="null" />, the default comparer for type T is used; if there is no default comparer, then the method throws <see cref="T:System.InvalidOperationException" />.  The default comparer for a given element type T is defined in the Description section of this (class <see langword="List&lt;T&gt;" />) specification.</para>
          <para>At worst, this operation is O(n<sup>2</sup>), where n is the number of elements to sort. On average it's O(n log n).</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentException">
          <paramref name="index" /> + <paramref name="count" /> is greater than <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</exception>
        <exception cref="T:System.ArgumentOutOfRangeException">
          <para>
            <paramref name="index" /> is less than zero.</para>
          <para>-or-</para>
          <para>
            <paramref name="count" /> is less than zero.</para>
        </exception>
        <exception cref="T:System.InvalidOperationException">
          <para>
            <paramref name="comparer" /> is <see langword="null" />, and the default comparer cannot find a <see cref="T:System.IComparable&lt;T&gt;" /> or <see cref="T:System.IComparable" /> implementation for type T.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.Generic.ICollection&lt;T&gt;.IsReadOnly">
      <MemberSignature Language="C#" Value="bool System.Collections.Generic.ICollection&lt;T&gt;.IsReadOnly { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>This read-only property is implemented to support the <see cref="T:System.Collections.Generic.ICollection&lt;T&gt;" /> interface.</para>
          <block subset="none" type="note">
            <para>For more information, see <see cref="P:System.Collections.Generic.ICollection&lt;T&gt;.IsReadOnly" />.</para>
          </block>
        </summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.Generic.IEnumerable&lt;T&gt;.GetEnumerator">
      <MemberSignature Language="C#" Value="System.Collections.Generic.IEnumerator&lt;T&gt; IEnumerable&lt;T&gt;.GetEnumerator ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.Generic.IEnumerator&lt;T&gt;</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.Generic.IEnumerable&lt;T&gt;" /> interface.</para>
        </summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.ICollection.CopyTo">
      <MemberSignature Language="C#" Value="void ICollection.CopyTo (Array array, int arrayIndex);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="array" Type="System.Array" />
        <Parameter Name="arrayIndex" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="array">To be added.</param>
        <param name="arrayIndex">To be added.</param>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.ICollection" /> interface.</para>
        </summary>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.ICollection.IsSynchronized">
      <MemberSignature Language="C#" Value="bool System.Collections.ICollection.IsSynchronized { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>This read-only property is implemented to support the <see cref="T:System.Collections.ICollection " /> interface.</para>
        </summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.ICollection.SyncRoot">
      <MemberSignature Language="C#" Value="object System.Collections.ICollection.SyncRoot { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Object</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>This read-only property is implemented to support the <see cref="T:System.Collections.ICollection " /> interface.</para>
        </summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IEnumerable.GetEnumerator">
      <MemberSignature Language="C#" Value="System.Collections.IEnumerator IEnumerable.GetEnumerator ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Collections.IEnumerator</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.IEnumerable" /> interface.</para>
        </summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.Add">
      <MemberSignature Language="C#" Value="int IList.Add (object item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="System.Object" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.Contains">
      <MemberSignature Language="C#" Value="bool IList.Contains (object item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="System.Object" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.IndexOf">
      <MemberSignature Language="C#" Value="int IList.IndexOf (object item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Int32</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="System.Object" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <returns>To be added.</returns>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.Insert">
      <MemberSignature Language="C#" Value="void IList.Insert (int index, object item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
        <Parameter Name="item" Type="System.Object" />
      </Parameters>
      <Docs>
        <param name="index">To be added.</param>
        <param name="item">To be added.</param>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.IsFixedSize">
      <MemberSignature Language="C#" Value="bool System.Collections.IList.IsFixedSize { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>This read-only property is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.IsReadOnly">
      <MemberSignature Language="C#" Value="bool System.Collections.IList.IsReadOnly { get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>
          <para>This read-only property is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.Item">
      <MemberSignature Language="C#" Value="object System.Collections.IList.Item[int index] { set; get; }" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>System.Object</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="index" Type="System.Int32" />
      </Parameters>
      <Docs>
        <param name="index">To be added.</param>
        <summary>
          <para>This read-only property is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="System.Collections.IList.Remove">
      <MemberSignature Language="C#" Value="void IList.Remove (object item);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="item" Type="System.Object" />
      </Parameters>
      <Docs>
        <param name="item">To be added.</param>
        <summary>
          <para>This method is implemented to support the <see cref="T:System.Collections.IList" /> interface.</para>
        </summary>
        <remarks>To be added.</remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="ToArray">
      <MemberSignature Language="C#" Value="public T[] ToArray ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>T[]</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Copies the elements in the list to a new array.</para>
        </summary>
        <returns>
          <para>The new array containing a copy of the list's elements.</para>
        </returns>
        <remarks>
          <para>This an O(n) operation, where n is <see cref="P:System.Collections.Generic.List&lt;T&gt;.Count" />.</para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="TrimExcess">
      <MemberSignature Language="C#" Value="public void TrimExcess ();" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>
          <para>Suggests that the capacity be reduced to the actual number of elements in the list.</para>
        </summary>
        <remarks>
          <para>This method can be used to suggest a collection's memory overhead be minimized, e.g., if no new elements are expected to be added to the collection.</para>
          <para>
            <block subset="none" type="note">To reset a list to its initial state, call the <see cref="M:System.Collections.Generic.List.Clear " /> method before calling <see cref="M:System.Collections.Generic.List.TrimExcess" />.</block>
          </para>
        </remarks>
        <since version=".NET 2.0" />
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
    <Member MemberName="TrueForAll">
      <MemberSignature Language="C#" Value="public bool TrueForAll (Predicate&lt;T&gt; match);" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="match" Type="System.Predicate&lt;T&gt;" />
      </Parameters>
      <Docs>
        <param name="match">The predicate delegate that specifies the check against the elements.</param>
        <summary>
          <para>Determines whether every element in the List matches the conditions defined by the specified predicate.</para>
        </summary>
        <returns>
          <para>
            <see langword="true" />, if every element in the List matches the conditions defined by the specified predicate; otherwise, <see langword="false" />.</para>
        </returns>
        <remarks>
          <para>The predicate is a delegate that returns <see langword="true" /> if the object passed to it matches the conditions defined in the delegate.  The elements of the current List are individually passed to the predicate delegate. The elements are processed sequentially and on the same thread.</para>
        </remarks>
        <since version=".NET 2.0" />
        <exception cref="T:System.ArgumentNullException">
          <para>
            <paramref name="match" /> is <see langword="null" />.</para>
        </exception>
      </Docs>
      <AssemblyInfo>
        <AssemblyVersion>2.0.0.0</AssemblyVersion>
      </AssemblyInfo>
    </Member>
  </Members>
</Type>
