IList Interface

[ This article is for Windows Phone 8 developers. If you’re developing for Windows 10, see the latest documentation. ]

Represents a non-generic collection of objects that can be individually accessed by index.

Namespace: System.Collections
Assembly: mscorlib (in mscorlib.dll)

Syntax

Public Interface IList _
    Inherits ICollection, IEnumerable
public interface IList : ICollection, IEnumerable

The IList type exposes the following members.

Properties

Name Description
Count Gets the number of elements contained in the ICollection. (Inherited from ICollection.)
IsFixedSize Gets a value indicating whether the IList has a fixed size.
IsReadOnly Gets a value indicating whether the IList is read-only.
IsSynchronized Gets a value indicating whether access to the ICollection is synchronized (thread safe). (Inherited from ICollection.)
Item Gets or sets the element at the specified index.
SyncRoot Gets an object that can be used to synchronize access to the ICollection. (Inherited from ICollection.)

Top

Methods

Name Description
Add Adds an item to the IList.
Clear Removes all items from the IList.
Contains Determines whether the IList contains a specific value.
CopyTo Copies the elements of the ICollection to an Array, starting at a particular Array index. (Inherited from ICollection.)
GetEnumerator Returns an enumerator that iterates through a collection. (Inherited from IEnumerable.)
IndexOf Determines the index of a specific item in the IList.
Insert Inserts an item to the IList at the specified index.
Remove Removes the first occurrence of a specific object from the IList.
RemoveAt Removes the IList item at the specified index.

Top

Extension Methods

Name Description
AsQueryable Converts an IEnumerable to an IQueryable. (Defined by Queryable.)
Cast<(Of <(TResult>)>) Converts the elements of an IEnumerable to the specified type. (Defined by Enumerable.)
OfType<(Of <(TResult>)>) Filters the elements of an IEnumerable based on a specified type. (Defined by Enumerable.)

Top

Remarks

IList is a descendant of the ICollection interface and is the base interface of all non-generic lists. IList implementations fall into three categories: read-only, fixed-size, and variable-size. A read-only IList cannot be modified. A fixed-size IList does not allow the addition or removal of elements, but it allows the modification of existing elements. A variable-size IList allows the addition, removal, and modification of elements.

For the generic version of this interface, see System.Collections.Generic..::.IList<(Of <(T>)>).

Examples

The following example demonstrates the implementation of the IList interface to create a simple list, fixed-size list.

Imports System.Collections

Public Class Example

   Public Shared Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      Dim myList As New SimpleList()

      ' Populate the List
      outputBlock.Text &= "Populate the List" & vbCrLf
      myList.Add("one")
      myList.Add("two")
      myList.Add("three")
      myList.Add("four")
      myList.Add("five")
      myList.Add("six")
      myList.Add("seven")
      myList.Add("eight")
      myList.PrintContents(outputBlock)
      outputBlock.Text &= vbCrLf

      ' Remove elements from the list
      outputBlock.Text &= "Remove elements from the list" & vbCrLf
      myList.Remove("six")
      myList.Remove("eight")
      myList.PrintContents(outputBlock)
      outputBlock.Text &= vbCrLf

      ' Add an element to the end of the list
      outputBlock.Text &= "Add an element to the end of the list" & vbCrLf
      myList.Add("nine")
      myList.PrintContents(outputBlock)
      outputBlock.Text &= vbCrLf

      ' Insert an element into the middle of the list
      outputBlock.Text &= "Insert an element into the middle of the list" & vbCrLf
      myList.Insert(4, "number")
      myList.PrintContents(outputBlock)
      outputBlock.Text &= vbCrLf

      ' Check for specific elements in the list
      outputBlock.Text &= "Check for specific elements in the list" & vbCrLf
      outputBlock.Text += String.Format("List contains 'three': {0}", myList.Contains("three")) & vbCrLf
      outputBlock.Text += String.Format("List contains 'ten': {0}", myList.Contains("ten")) & vbCrLf

   End Sub
End Class ' class Program

Public Class SimpleList
   Implements IList

   Private _contents(8) As Object
   Private _count As Integer

   Public Sub New()

      _count = 0
   End Sub

   ' IList Members
   Public Function Add(ByVal value As Object) As Integer Implements IList.Add

      If (_count < _contents.Length - 1) Then

         _contents(_count) = value
         _count = _count + 1

         Return (_count - 1)

      Else

         Return -1
      End If
   End Function

   Public Sub Clear() Implements IList.Clear
      _count = 0
   End Sub

   Public Function Contains(ByVal value As Object) As Boolean Implements IList.Contains

      Dim inList As Boolean = False

      Dim i As Integer
      For i = 0 To Count

         If _contents(i) = value Then

            inList = True
            Exit For

         End If

      Next i

      Return inList
   End Function

   Public Function IndexOf(ByVal value As Object) As Integer Implements IList.IndexOf

      Dim itemIndex As Integer = -1

      Dim i As Integer
      For i = 0 To Count

         If _contents(i) = value Then

            itemIndex = i
            Exit For

         End If

      Next i

      Return itemIndex
   End Function

   Public Sub Insert(ByVal index As Integer, ByVal value As Object) Implements IList.Insert

      If (_count + 1) <= (_contents.Length - 1) And (index < Count) And (index >= 0) Then

         _count = _count + 1

         Dim i As Integer
         For i = Count - 1 To index

            _contents(i) = _contents(i - 1)
         Next i

         _contents(index) = value
      End If
   End Sub

   Public ReadOnly Property IsFixedSize() As Boolean Implements IList.IsFixedSize
      Get
         Return True
      End Get
   End Property

   Public ReadOnly Property IsReadOnly() As Boolean Implements IList.IsReadOnly

      Get
         Return False
      End Get
   End Property

   Public Sub Remove(ByVal value As Object) Implements IList.Remove
      RemoveAt(IndexOf(value))
   End Sub

   Public Sub RemoveAt(ByVal index As Integer) Implements IList.RemoveAt

      If index >= 0 And index < Count Then

         Dim i As Integer
         For i = index To Count - 1

            _contents(i) = _contents(i + 1)
         Next i
         _count = _count - 1

      End If
   End Sub

   Public Property Item(ByVal index As Integer) As Object Implements IList.Item

      Get
         Return _contents(index)
      End Get

      Set(ByVal value As Object)
         _contents(index) = value
      End Set
   End Property

   ' ICollection Members

   Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements ICollection.CopyTo
      Dim j As Integer = index
      Dim i As Integer
      For i = 0 To Count
         array.SetValue(_contents(i), j)
         j = j + 1
      Next i
   End Sub

   Public ReadOnly Property Count() As Integer Implements ICollection.Count
      Get
         Return _count
      End Get
   End Property

   Public ReadOnly Property IsSynchronized() As Boolean Implements ICollection.IsSynchronized
      Get
         Return False
      End Get
   End Property

   ' Return the current instance since the underlying store is not
   ' publicly available.
   Public ReadOnly Property SyncRoot() As Object Implements ICollection.SyncRoot
      Get
         Return Me
      End Get
   End Property

   ' IEnumerable Members
   Public Function GetEnumerator() As IEnumerator Implements IEnumerable.GetEnumerator

      ' Refer to the IEnumerator documentation for an example of
      ' implementing an enumerator.
      Throw New Exception("The method or operation is not implemented.")
   End Function

   Public Sub PrintContents(ByVal outputBlock As System.Windows.Controls.TextBlock)

      outputBlock.Text += String.Format("List has a capacity of {0} and currently has {1} elements.", _contents.Length - 1, _count) & vbCrLf
      outputBlock.Text &= "List contents:"

      Dim i As Integer
      For i = 0 To Count

         outputBlock.Text += String.Format(" {0}", _contents(i))
      Next i

      outputBlock.Text &= vbCrLf

   End Sub
End Class

' This code produces output similar to the following:
' Populate the List:
' List has a capacity of 8 and currently has 8 elements.
' List contents: one two three four five six seven eight
'
' Remove elements from the list:
' List has a capacity of 8 and currently has 6 elements.
' List contents: one two three four five seven
'
' Add an element to the end of the list:
' List has a capacity of 8 and currently has 7 elements.
' List contents: one two three four five seven nine
'
' Insert an element into the middle of the list:
' List has a capacity of 8 and currently has 8 elements.
' List contents: one two three four number five seven nine
'
' Check for specific elements in the list:
' List contains "three": True
' List contains "ten": False
using System;
using System.Collections;

class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      SimpleList test = new SimpleList();

      // Populate the List
      outputBlock.Text += "Populate the List" + "\n";
      test.Add("one");
      test.Add("two");
      test.Add("three");
      test.Add("four");
      test.Add("five");
      test.Add("six");
      test.Add("seven");
      test.Add("eight");
      test.PrintContents(outputBlock);
      outputBlock.Text += "\n";

      // Remove elements from the list
      outputBlock.Text += "Remove elements from the list" + "\n";
      test.Remove("six");
      test.Remove("eight");
      test.PrintContents(outputBlock);
      outputBlock.Text += "\n";

      // Add an element to the end of the list
      outputBlock.Text += "Add an element to the end of the list" + "\n";
      test.Add("nine");
      test.PrintContents(outputBlock);
      outputBlock.Text += "\n";

      // Insert an element into the middle of the list
      outputBlock.Text += "Insert an element into the middle of the list" + "\n";
      test.Insert(4, "number");
      test.PrintContents(outputBlock);
      outputBlock.Text += "\n";

      // Check for specific elements in the list
      outputBlock.Text += "Check for specific elements in the list" + "\n";
      outputBlock.Text += String.Format("List contains \"three\": {0}", test.Contains("three")) + "\n";
      outputBlock.Text += String.Format("List contains \"ten\": {0}", test.Contains("ten")) + "\n";
   }
} // class Program

class SimpleList : IList
{
   private object[] _contents = new object[8];
   private int _count;

   public SimpleList()
   {
      _count = 0;
   }

   // IList Members
   public int Add(object value)
   {
      if (_count < _contents.Length)
      {
         _contents[_count] = value;
         _count++;

         return (_count - 1);
      }
      else
      {
         return -1;
      }
   }

   public void Clear()
   {
      _count = 0;
   }

   public bool Contains(object value)
   {
      bool inList = false;
      for (int i = 0; i < Count; i++)
      {
         if (_contents[i] == value)
         {
            inList = true;
            break;
         }
      }
      return inList;
   }

   public int IndexOf(object value)
   {
      int itemIndex = -1;
      for (int i = 0; i < Count; i++)
      {
         if (_contents[i] == value)
         {
            itemIndex = i;
            break;
         }
      }
      return itemIndex;
   }

   public void Insert(int index, object value)
   {
      if ((_count + 1 <= _contents.Length) && (index < Count) && (index >= 0))
      {
         _count++;

         for (int i = Count - 1; i > index; i--)
         {
            _contents[i] = _contents[i - 1];
         }
         _contents[index] = value;
      }
   }

   public bool IsFixedSize
   {
      get
      {
         return true;
      }
   }

   public bool IsReadOnly
   {
      get
      {
         return false;
      }
   }

   public void Remove(object value)
   {
      RemoveAt(IndexOf(value));
   }

   public void RemoveAt(int index)
   {
      if ((index >= 0) && (index < Count))
      {
         for (int i = index; i < Count - 1; i++)
         {
            _contents[i] = _contents[i + 1];
         }
         _count--;
      }
   }

   public object this[int index]
   {
      get
      {
         return _contents[index];
      }
      set
      {
         _contents[index] = value;
      }
   }

   // ICollection Members

   public void CopyTo(Array array, int index)
   {
      int j = index;
      for (int i = 0; i < Count; i++)
      {
         array.SetValue(_contents[i], j);
         j++;
      }
   }

   public int Count
   {
      get
      {
         return _count;
      }
   }

   public bool IsSynchronized
   {
      get
      {
         return false;
      }
   }

   // Return the current instance since the underlying store is not
   // publicly available.
   public object SyncRoot
   {
      get
      {
         return this;
      }
   }

   // IEnumerable Members

   public IEnumerator GetEnumerator()
   {
      // Refer to the IEnumerator documentation for an example of
      // implementing an enumerator.
      throw new Exception("The method or operation is not implemented.");
   }

   public void PrintContents(System.Windows.Controls.TextBlock outputBlock)
   {
      outputBlock.Text += String.Format("List has a capacity of {0} and currently has {1} elements.", _contents.Length, _count) + "\n";
      outputBlock.Text += "List contents:";
      for (int i = 0; i < Count; i++)
      {
         outputBlock.Text += String.Format(" {0}", _contents[i]);
      }
      outputBlock.Text += "\n";
   }
}

// This code produces output similar to the following:
// Populate the List:
// List has a capacity of 8 and currently has 8 elements.
// List contents: one two three four five six seven eight
//
// Remove elements from the list:
// List has a capacity of 8 and currently has 6 elements.
// List contents: one two three four five seven
//
// Add an element to the end of the list:
// List has a capacity of 8 and currently has 7 elements.
// List contents: one two three four five seven nine
//
// Insert an element into the middle of the list:
// List has a capacity of 8 and currently has 8 elements.
// List contents: one two three four number five seven nine
//
// Check for specific elements in the list:
// List contains "three": True
// List contains "ten": False

Version Information

Windows Phone OS

Supported in: 8.1, 8.0, 7.1, 7.0

Platforms

Windows Phone

See Also

Reference

System.Collections Namespace

ICollection

System.Collections.Generic..::.IList<(Of <(T>)>)