Export (0) Print
Expand All

ArrayList.ReadOnly Method

Returns a list wrapper that is read-only.

Overload List

Returns a read-only ArrayList wrapper.

[Visual Basic] Overloads Public Shared Function ReadOnly(ArrayList) As ArrayList
[C#] public static ArrayList ReadOnly(ArrayList);
[C++] public: static ArrayList* ReadOnly(ArrayList*);
[JScript] public static function ReadOnly(ArrayList) : ArrayList;

Returns a read-only IList wrapper.

[Visual Basic] Overloads Public Shared Function ReadOnly(IList) As IList
[C#] public static IList ReadOnly(IList);
[C++] public: static IList* ReadOnly(IList*);
[JScript] public static function ReadOnly(IList) : IList;

Example

[Visual Basic, C#, C++] The following example shows how to create a read-only wrapper around an ArrayList and how to determine if an ArrayList is read-only.

[Visual Basic, C#, C++] Note   This example shows how to use one of the overloaded versions of ReadOnly. For other examples that might be available, see the individual overload topics.
[Visual Basic] 
Imports System
Imports System.Collections

Public Class SamplesArrayList

   Public Shared Sub Main()

      Dim myStr As [String]

      ' Creates and initializes a new ArrayList.
      Dim myAL As New ArrayList()
      myAL.Add("red")
      myAL.Add("orange")
      myAL.Add("yellow")

      ' Creates a read-only copy of the ArrayList.
      Dim myReadOnlyAL As ArrayList = ArrayList.ReadOnly(myAL)

      ' Displays whether the ArrayList is read-only or writable.
      If myAL.IsReadOnly Then
         Console.WriteLine("myAL is read-only.")
      Else
         Console.WriteLine("myAL is writable.")
      End If
      If myReadOnlyAL.IsReadOnly Then
         Console.WriteLine("myReadOnlyAL is read-only.")
      Else
         Console.WriteLine("myReadOnlyAL is writable.")
      End If

      ' Displays the contents of both collections.
      Console.WriteLine()
      Console.WriteLine("Initially,")
      Console.WriteLine("The original ArrayList myAL contains:")
      For Each myStr In  myAL
         Console.WriteLine("   {0}", myStr)
      Next myStr
      Console.WriteLine("The read-only ArrayList myReadOnlyAL contains:")
      For Each myStr In  myReadOnlyAL
         Console.WriteLine("   {0}", myStr)
      Next myStr 

      ' Adding an element to a read-only ArrayList throws an exception.
      Console.WriteLine()
      Console.WriteLine("Trying to add a new element to the read-only ArrayList:")
      Try
         myReadOnlyAL.Add("green")
      Catch myException As Exception
         Console.WriteLine(("Exception: " + myException.ToString()))
      End Try

      ' Adding an element to the original ArrayList affects the read-only ArrayList.
      myAL.Add("blue")

      ' Displays the contents of both collections again.
      Console.WriteLine()
      Console.WriteLine("After adding a new element to the original ArrayList,")
      Console.WriteLine("The original ArrayList myAL contains:")
      For Each myStr In  myAL
         Console.WriteLine("   {0}", myStr)
      Next myStr
      Console.WriteLine("The read-only ArrayList myReadOnlyAL contains:")
      For Each myStr In  myReadOnlyAL
         Console.WriteLine("   {0}", myStr)
      Next myStr 

   End Sub 'Main

End Class 'SamplesArrayList 


'This code produces the following output.
'
'myAL is writable.
'myReadOnlyAL is read-only.
'
'Initially,
'The original ArrayList myAL contains:
'   red
'   orange
'   yellow
'The read-only ArrayList myReadOnlyAL contains:
'   red
'   orange
'   yellow
'
'Trying to add a new element to the read-only ArrayList:
'Exception: System.NotSupportedException: Collection is read-only.
'   at System.Collections.ReadOnlyArrayList.Add(Object obj)
'   at SamplesArrayList.Main()
'
'After adding a new element to the original ArrayList,
'The original ArrayList myAL contains:
'   red
'   orange
'   yellow
'   blue
'The read-only ArrayList myReadOnlyAL contains:
'   red
'   orange
'   yellow
'   blue


[C#] 
using System;
using System.Collections;
public class SamplesArrayList  {

   public static void Main()  {

      // Creates and initializes a new ArrayList.
      ArrayList myAL = new ArrayList();
      myAL.Add( "red" );
      myAL.Add( "orange" );
      myAL.Add( "yellow" );

      // Creates a read-only copy of the ArrayList.
      ArrayList myReadOnlyAL = ArrayList.ReadOnly( myAL );

      // Displays whether the ArrayList is read-only or writable.
      Console.WriteLine( "myAL is {0}.", myAL.IsReadOnly ? "read-only" : "writable" );
      Console.WriteLine( "myReadOnlyAL is {0}.", myReadOnlyAL.IsReadOnly ? "read-only" : "writable" );

      // Displays the contents of both collections.
      Console.WriteLine( "\nInitially," );
      Console.WriteLine( "The original ArrayList myAL contains:" );
      foreach ( String myStr in myAL )
         Console.WriteLine( "   {0}", myStr );
      Console.WriteLine( "The read-only ArrayList myReadOnlyAL contains:" );
      foreach ( String myStr in myReadOnlyAL )
         Console.WriteLine( "   {0}", myStr );

      // Adding an element to a read-only ArrayList throws an exception.
      Console.WriteLine( "\nTrying to add a new element to the read-only ArrayList:" );
      try  {
         myReadOnlyAL.Add("green");
      } catch ( Exception myException )  {
         Console.WriteLine("Exception: " + myException.ToString());
      }

      // Adding an element to the original ArrayList affects the read-only ArrayList.
      myAL.Add( "blue" );

      // Displays the contents of both collections again.
      Console.WriteLine( "\nAfter adding a new element to the original ArrayList," );
      Console.WriteLine( "The original ArrayList myAL contains:" );
      foreach ( String myStr in myAL )
         Console.WriteLine( "   {0}", myStr );
      Console.WriteLine( "The read-only ArrayList myReadOnlyAL contains:" );
      foreach ( String myStr in myReadOnlyAL )
         Console.WriteLine( "   {0}", myStr );

   }

}


/* 
This code produces the following output.

myAL is writable.
myReadOnlyAL is read-only.

Initially,
The original ArrayList myAL contains:
  red
  orange
  yellow
The read-only ArrayList myReadOnlyAL contains:
  red
  orange
  yellow

Trying to add a new element to the read-only ArrayList:
Exception: System.NotSupportedException: Collection is read-only.
  at System.Collections.ReadOnlyArrayList.Add(Object obj)
  at SamplesArrayList.Main()

After adding a new element to the original ArrayList,
The original ArrayList myAL contains:
  red
  orange
  yellow
  blue
The read-only ArrayList myReadOnlyAL contains:
  red
  orange
  yellow
  blue

*/


[C++] 
#using <mscorlib.dll>
#using <system.dll>

using namespace System;
using namespace System::Collections;

int main()  {

       // Creates and initializes a new ArrayList.
       ArrayList* myAL = new ArrayList();
       myAL->Add( S"red" );
       myAL->Add( S"orange" );
       myAL->Add( S"yellow" );

       // Creates a read-only copy of the ArrayList.
       ArrayList* myReadOnlyAL = ArrayList::ReadOnly( myAL );

       // Displays whether the ArrayList is read-only or writable.
       Console::WriteLine( S"myAL is {0}.", myAL->IsReadOnly ? S"read-only" : S"writable" );
       Console::WriteLine( S"myReadOnlyAL is {0}.", myReadOnlyAL->IsReadOnly ? S"read-only" : S"writable" );

       // Displays the contents of both collections.
       Console::WriteLine( S"\nInitially," );
       Console::WriteLine( S"The original ArrayList myAL contains:" );
       for( int i(0); i < myAL->Count; ++i )
             Console::WriteLine( "   {0}", static_cast<String*>(myAL->Item[i]) );
       Console::WriteLine( S"The read-only ArrayList myReadOnlyAL contains:" );
       for( int i(0); i < myReadOnlyAL->Count; ++i )
          Console::WriteLine( S"   {0}", static_cast<String*>(myReadOnlyAL->Item[i]) );

       // Adding an element to a read-only ArrayList throws an exception.
       Console::WriteLine( S"\nTrying to add a new element to the read-only ArrayList:" );
       try  {
          myReadOnlyAL->Add(S"green");
       } catch ( Exception* myException )  {
          Console::WriteLine( String::Concat(S"Exception: ", myException->ToString()));
       }

       // Adding an element to the original ArrayList affects the read-only ArrayList.
       myAL->Add( S"blue" );

       // Displays the contents of both collections again.
       Console::WriteLine( S"\nAfter adding a new element to the original ArrayList," );
       Console::WriteLine( S"The original ArrayList myAL contains:" );
       for( int i(0); i < myAL->Count; ++i )
          Console::WriteLine( S"   {0}", static_cast<String*>(myAL->Item[i]) );
       Console::WriteLine( S"The read-only ArrayList myReadOnlyAL contains:" );
       for( int i(0); i < myReadOnlyAL->Count; ++i )
          Console::WriteLine( S"   {0}", static_cast<String*>(myReadOnlyAL->Item[i]) );

}

/*
This code produces the following output.

myAL is writable.
myReadOnlyAL is read-only.

Initially,
The original ArrayList myAL contains:
   red
   orange
   yellow
The read-only ArrayList myReadOnlyAL contains:
   red
   orange
   yellow

Trying to add a new element to the read-only ArrayList:
Exception: System.NotSupportedException: Collection is read-only.
   at System.Collections.ReadOnlyArrayList.Add(Object obj)
   at SamplesArrayList.Main()

After adding a new element to the original ArrayList,
The original ArrayList myAL contains:
   red
   orange
   yellow
   blue
The read-only ArrayList myReadOnlyAL contains:
   red
   orange
   yellow
   blue

*/

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

See Also

ArrayList Class | ArrayList Members | System.Collections Namespace

Show:
© 2014 Microsoft