C#

Smithers-Jones wrote:

He definitely astonished me with his exceptional first impression of an angry elephant with constipation

Smithers-Jones wrote:

an angry elephant with constipation

Smithers-Jones wrote:

a monkey with rabies

DaveyM69 wrote:

It's just a shame it's too long for a quote in a signature!

Lee Reid wrote:

My project has several deriving classes, and values being entirely 'readonly' defeats the purpose of the whole class

class A {}

class B : A {}

class C : A {}

class MyClass {
  private List<B> listB;
  private List<C> listC;

  public MyClass() {
    // Initialize lists...
  }

  public IEnumerable<A> GetAllItems() {
    // Get each list in this class as IEnumerable<A>
    IEnumerable<A> b = listB;
    IEnumerable<A> c = listC;

    return b.Concat(c);
  }
}

public static List<TBase> DerivedConverter<TBase, TDerived>(List<TDerived> derivedList)
    where TDerived : TBase
{
    return derivedList.ConvertAll<TBase>(
       new Converter<TDerived, TBase>(delegate(TDerived derived)
       {
           return derived;
       }));
}

List<Base> listBase = DerivedConverter<Base, Derived>(listDerived);

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        Derived derived1 = new Derived(1);
        Derived derived2 = new Derived(2);
        List<Derived> listDerived = new List<Derived>(new Derived[] { derived1, derived2 });
        // Create Base list
        List<Base> listBase = DerivedConverter<Base, Derived>(listDerived);
        // Make change to derived list
        listDerived[0].ID = 0;
        for (int i = 0; i < listBase.Count; i++)
        {
            Console.WriteLine("{0} {1}",
                object.ReferenceEquals(listBase[i], listDerived[i]),
                listBase[i].ID);
        }
        Console.ReadKey();
    }
    public static List<TBase> DerivedConverter<TBase, TDerived>(List<TDerived> derivedList)
            where TDerived : TBase
    {
        return derivedList.ConvertAll<TBase>(
               new Converter<TDerived, TBase>(delegate(TDerived derived)
               {
                   return derived;
               }));
    }
}

public class Base
{
    public Base(int id)
    {
        ID = id;
    }
    public int ID { get; set; }
}

public class Derived : Base
{
    public Derived(int id)
        : base(id)
    { }
}

public class BaseList<TBase, TDerived1, TDerived2>
    where TDerived1 : TBase
    where TDerived2 : TBase
{
    private List<TDerived1> derived1List;
    private List<TDerived2> derived2List;

    public List<TDerived1> Derived1List
    {
        get { return derived1List; }
        set { derived1List = value; }
    }
    public List<TDerived2> Derived2List
    {
        get { return derived2List; }
        set { derived2List = value; }
    }
    public ReadOnlyCollection<TBase> BaseCollection
    {
        get
        {
            List<TBase> baseList = DerivedConverter<TBase, TDerived1>(derived1List);
            baseList.AddRange(DerivedConverter<TBase, TDerived2>(derived2List));
            return baseList.AsReadOnly();
        }
    }

    private static List<TBase> DerivedConverter<TBase, TDerived>(List<TDerived> derivedList)
            where TDerived : TBase
    {
        return derivedList.ConvertAll<TBase>(
               new Converter<TDerived, TBase>(delegate(TDerived derived)
               {
                   return derived;
               }));
    }
}

public static System.Collections.Generic.IEnumerable<T>
Enumerate<T>
(
    params System.Collections.Generic.IEnumerable<T>[] Lists
)
{
    foreach
    (
        System.Collections.Generic.IEnumerable<T> list
    in
        Lists
    )
    {
        foreach
        (
            T t
        in
            list
        )
        {
            yield return ( t ) ;
        }
    }

    yield break ;
}