ReadOnlyCB.cs

/*
    Questo esempio implementa una collezione di sola lettura Orders_RO per elementi di tipo 
    Order. La classe Orders_RO è ottenuta derivando da ReadOnlyCollectionBase. Alla classe 
    comunque  sono stati aggiunti i metodi Strong-Typed per il costruttore e per IEnumerable.
*/

using sys = System;
using sysCols = System.Collections;

//
//-----------------------------------------------------------------------------------------------
// Main App
//-----------------------------------------------------------------------------------------------
//

class MainApp{
  public static void Main(){
    //
    // Esercito i costruttori tipizzati
    //
    Order[] myOrdersArray = new Order[10];
    for(int i = myOrdersArray.GetLowerBound(0); i<=myOrdersArray.GetUpperBound(0); ++i)
      myOrdersArray[i] = new Order();
    Orders_RO myOrders_RO = new Orders_RO(myOrdersArray);
    {
      Orders_RO myTmpOrders  = new Orders_RO(myOrders_RO);      

      // error CS1502: The best overloaded method match for 'Orders_RO.Orders_RO(Order[])' has some invalid arguments
      // Scommenta la linea di codice per verificare che il costruttore tipizzato funziona
      //Orders_RO myTmpOrders2 = new Orders_RO(new object[10]);      
    }
  
    //
    // Esercito l'enumeratore tipizzato
    //
    foreach(Order ord in myOrders_RO)
      sys.Console.WriteLine("Ordine n {0} presente!", ord.Number);

    // error CS0030: Cannot convert type 'Order' to 'string'
    // Scommenta la linea di codice per verificare che il costruttore tipizzato funziona
    //foreach(string ord in myOrders_RO);

    // Scommenta per verificare che il costruttore non tipizzato funziona sempre
    //foreach(object ord in myOrders_RO) {sys.Console.WriteLine(ord);}

    return;
  }
}


//
//-----------------------------------------------------------------------------------------------
// Item: Order
//-----------------------------------------------------------------------------------------------
//
public class Order {
  private static int globalNum = 1000;
  private int num = ++globalNum;
  private string customer;

  public string Customer {
    get {return customer;}
    set {customer = value;}
  }

  public int Number {
    get {return num;}
  }
}
    
//    
//-----------------------------------------------------------------------------------------------
// Collection: Orders_RO
//-----------------------------------------------------------------------------------------------
//
public class Orders_RO : sysCols.ReadOnlyCollectionBase {

  //////////////////////////////////////////////////////////////////////////////////
  // FOUNDATION MEMBERS
  //////////////////////////////////////////////////////////////////////////////////

  // Default Constructor
  public Orders_RO() {}        
  // Constructor
  public Orders_RO(Order[] value) 
  {
    for (int i = 0; (i < value.Length); i = (i + 1)) 
      InnerList.Add(value[i]);
  }
  // Copy-Constructor
  public Orders_RO(Orders_RO value) 
  {
    for (int i = 0; (i < value.Count); i = (i + 1)) 
      InnerList.Add(value[i]);
  }
        
  //////////////////////////////////////////////////////////////////////////////////
  // ACCESSOR MEMBERS
  //////////////////////////////////////////////////////////////////////////////////

  public Order this[int index] 
  {
    get {return ((Order)(InnerList[index]));}
  }
  
  // Type-safe version of ICollection.CopyTo
  public void CopyTo(Order[] array, int index) {InnerList.CopyTo(array, index);}
        
  // Type-safe version of IEnumerable.GetEnumerator
  public new OrderEnumerator GetEnumerator() {
    return new OrderEnumerator(this);
  }
                        
  //////////////////////////////////////////////////////////////////////////////////
  // NESTED ITERATOR
  //////////////////////////////////////////////////////////////////////////////////

  // Type-safe nested iterator class
  public class OrderEnumerator : sysCols.IEnumerator {            
    private sysCols.IEnumerator baseEnumerator;            
            
    public OrderEnumerator(Orders_RO mappings) {
      sysCols.IEnumerable temp = ((sysCols.IEnumerable)(mappings));
      this.baseEnumerator = temp.GetEnumerator();
    }
            
    // Type-safe iterator Current method 
    public Order Current {
      get {return ((Order)(baseEnumerator.Current));}
    }
           
    // Type-unsafe IEnumerator.Current
    object sysCols.IEnumerator.Current {
      get {return baseEnumerator.Current;}
      }
            
    public bool MoveNext() {return baseEnumerator.MoveNext();}            
    bool sysCols.IEnumerator.MoveNext() {return baseEnumerator.MoveNext();}
            
    public void Reset() {baseEnumerator.Reset();}            
    void sysCols.IEnumerator.Reset() {baseEnumerator.Reset();}
  }
}