C#

Pete O'Hanlon wrote:

But it deserved an answer.

private class C
{
   public string Name { get ; private set ; }

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

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

private class A : C
{
   public A ( string Name ) : base ( Name ) {}
}

private class B : C
{
   public B ( string Name ) : base ( Name ) {}
}

private static System.Collections.Generic.List<A> alist = new System.Collections.Generic.List<A>() ;
private static System.Collections.Generic.List<B> blist = new System.Collections.Generic.List<B>() ;

private static System.Collections.Generic.IEnumerable<C>
All
(
  params System.Collections.Generic.IEnumerable<C>[] lists
)
{
  foreach ( System.Collections.Generic.IEnumerable<C> l in lists )
  {
    foreach ( C c in l )
    {
      yield return ( c ) ;
    }
  }

  yield break ;
}

foreach ( C c in All ( alist , blist ) )
{
  System.Console.WriteLine ( c ) ;
}

public IEnumerable<MyBase> All
{
    get
    {
        foreach (MyBase myBase in MyFooCollection)
            yield return myBase;
        foreach (MyBase myBase in MyBarCollection)
            yield return myBase;
        yield break;
    }
}

foreach(someType a in collection) {
    foreach (someType b in collection) {
        if (a!=b) doSomeThingTo(a,b);
    }
}

Luc Pattyn wrote:

FWIW: are you familiar with AsReadOnly?

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);
}