C#

public static IList<MyFoo> MyFoos;
//
// and later ... after creating and initializing 'MyFooCollection<MyFoo>:
//
MyFoos = MyFooCollection.AsReadOnly();

public class ImmutableCollection<T> : IEnumerable<T>
{
    private List<T> innerList;

    public ImmutableCollection(IEnumerable<T> collection)
    {
        innerList = new List<T>(collection);
    }

    public T this[int index]
    {
        get { return innerList[index]; }
    }
    public int Count
    {
        get { return innerList.Count; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IEnumerable<T>)innerList).GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IEnumerable)innerList).GetEnumerator();
    }
}

ImmutableCollection<string> collection = new ImmutableCollection<string>(new string[] { "A", "B", "C" });

using System;
using System.Collections;
using System.Collections.Generic;

public enum BaseType
{
    MyFoo,
    MyBar
}

public abstract class MyBase
{
    private BaseType baseType;
    private string name;

    internal MyBase(BaseType baseType, string name)
    {
        this.baseType = baseType;
        this.name = name;
    }

    public string Name
    {
        get { return name; }
    }

    public override string ToString()
    {
        return string.Format("Type: {0}, Name: {1}", baseType, name);
    }
}

public sealed class MyFoo : MyBase
{
    internal MyFoo(string name)
        : base(BaseType.MyFoo, name)
    { }
}

public sealed class MyBar : MyBase
{
    internal MyBar(string name)
        : base(BaseType.MyBar, name)
    { }
}

public class SimpleCollection<T> : IEnumerable<T>
{
    private List<T> innerList;

    public SimpleCollection(IEnumerable<T> items)
    {
        innerList = new List<T>(items);
    }

    public T this[int index]
    {
        get { return innerList[index]; }
    }
    public int Count
    {
        get { return innerList.Count; }
    }

    public IEnumerator<T> GetEnumerator()
    {
        return innerList.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return innerList.GetEnumerator();
    }
}

public class MyFooCollection : SimpleCollection<MyFoo>
{
    internal MyFooCollection(IEnumerable<MyFoo> myFoos)
        : base(myFoos)
    { }
}

public class MyBarCollection : SimpleCollection<MyBar>
{
    internal MyBarCollection(IEnumerable<MyBar> myBars)
        : base(myBars)
    { }
}

// In my real code this is a singleton so there will only ever be one pool
public class MyFooMyBarPool
{
    private MyFooCollection myFooCollection;
    private MyBarCollection myBarCollection;

    public MyFooMyBarPool()
    {
        // Items and collections are instanciated here only.
        myFooCollection = new MyFooCollection(new MyFoo[] { new MyFoo("A"), new MyFoo("B"), new MyFoo("C") });
        myBarCollection = new MyBarCollection(new MyBar[] { new MyBar("A"), new MyBar("B"), new MyBar("C") });
    }

    public IEnumerable<MyBase> MyBases
    {
        get
        {
            IEnumerator<MyFoo> myFooEnumerator = myFooCollection.GetEnumerator();
            while (myFooEnumerator.MoveNext())
                yield return myFooEnumerator.Current;
            IEnumerator<MyBar> myBarEnumerator = myBarCollection.GetEnumerator();
            while (myBarEnumerator.MoveNext())
                yield return myBarEnumerator.Current;
            yield break;
        }
    }
    public MyFooCollection MyFoos
    {
        get { return myFooCollection; }
    }
    public MyFooCollection MyBars
    {
        get { return myFooCollection; }
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyFooMyBarPool pool = new MyFooMyBarPool();
        foreach (MyBase myBase in pool.MyBases)
            Console.WriteLine(myBase);
        Console.WriteLine(
            "{0} MyFoo and {1} MyBar items", 
            pool.MyFoos.Count, pool.MyBars.Count);
        Console.ReadKey();
    }
}

int count1=0;
foreach(someType element in collection) count1++;

int count2=0;
foreach(someType element1 in collection) {
    foreach(someType element2 in collection) {
        count2++;
    }
}
if (count2!=count1*count1) noGood();

DaveyM69 wrote:

How about getting the enumerator

public Enumerator GetEnumerator()
{
    return new Enumerator((List<T>) this);
}

IEnumerator<MyFoo> myFooEnumerator = myFooCollection.GetEnumerator();
while (myFooEnumerator.MoveNext())
    yield return myFooEnumerator.Current;
IEnumerator<MyBar> myBarEnumerator = myBarCollection.GetEnumerator();
while (myBarEnumerator.MoveNext())
    yield return myBarEnumerator.Current;

private abstract class C
{
    public static readonly List<A> alist = new List<A>();
    public static readonly List<B> blist = new List<B>();
    public static readonly List<C> clist = new List<C>();

    public string Name { get; private set; }

    public C(string Name)
    {
        this.Name = Name;

        clist.Add(this);

        if(this is A)
        {
            alist.Add(this as A);
        }
        else
        {
            blist.Add(this as B);
        }
    }

    public override string ToString() { return (this.Name); }
}

A myA1 = new A("a1");
A myA2 = new A("a2");
B myB1 = new B("b1");
B myB2 = new B("b2");

foreach (var a in C.alist)
{
    Console.WriteLine("This A's Name is : " + a.Name);
}

foreach (var b in C.blist)
{
    Console.WriteLine("This B's Name is : " + b.Name);
}

foreach (var c in C.clist)
{
    Console.WriteLine("This C is a Type: " + c.GetType() + " : Name = " + c.Name);
}

This A's Name is : a1
This A's Name is : a2
This B's Name is : b1
This B's Name is : b2
This C is a Type: TestImmutable.Form1+A : Name = a1
This C is a Type: TestImmutable.Form1+A : Name = a2
This C is a Type: TestImmutable.Form1+B : Name = b1
This C is a Type: TestImmutable.Form1+B : Name = b2

DataColumn myDataColumn;
myDataColumn = new DataColumn();
myDataColumn.DataType = System.Type.GetType("System.Int32");
myDataColumn.ColumnName = "id";
myDataColumn.ReadOnly = true;
myDataColumn.Unique = true;

myDataTable.Columns.Add(myDataColumn);

Brian Reiber wrote:

input = Console.ReadLine();
LastName = Convert.ToString(input);

public static string ToString(string value)
{
    return value;
}

Brian Reiber wrote:

stringinput

Brian Reiber wrote:

input = Console.ReadLine();
FirstName = Convert.ToString(input);

Brian Reiber wrote:

Convert

Brian Reiber wrote:

{1} ... , payRate[x].ToString("C")

Deborah Palmer McCain wrote:

I don't do well with books I cannot markup with pencil notations.