C# 3.5: Generics, polymorfi, NUnit test, Rhino mocks

using System;

namespace E
{
    public interface IBaseBusiness<T>
    {
        T GetObject();
    }
    public class Foo 
    {
        public override string ToString()
        {
            return "I am a Foo";
        }
    }
    public class Bar
    {
        public override string ToString()
        {
            return "I am a Bar";
        }
    }
    public class FooBusiness : IBaseBusiness<Foo>
    {
        public Foo GetObject()
        {
            return new Foo();
        }
    }
    public class BarBusiness : IBaseBusiness<Bar>
    {
        public Bar GetObject()
        {
            return new Bar();
        }
    }
    public abstract class LazyLoadTest
    {
        protected abstract object GetBusinessObject(Type theType);
        public void TestLazyLoad(string typnam)
        {
            // compile time error when calling GetObject
            object business = GetBusinessObject(Type.GetType(typnam));
            // runtime error when assigning
            IBaseBusiness<object> business = (IBaseBusiness<object>)GetBusinessObject(Type.GetType(typnam));
            Console.WriteLine(business.GetObject());
        }
    }
    public class CompanyEntityTest : LazyLoadTest
    {
          protected override object GetBusinessObject(Type theType)
        {
              if(theType == typeof(Foo))
              {
                  return new FooBusiness();
              }
              else if(theType == typeof(Bar))
              {
                  return new BarBusiness();
              }
              else
              {
                  throw new Exception("No Foo or Bar");
              }
          }
    }
    public class Program
    {
        public static void Main(string[] args)
        {
            CompanyEntityTest cet = new CompanyEntityTest();
            cet.TestLazyLoad("E.Foo");
            cet.TestLazyLoad("E.Bar");
            Console.ReadKey();
        }
    }
}

using System;

namespace E
{
    public interface IBaseBusiness
    {
        object GetObject();
    }
    public interface IBaseBusiness<T> : IBaseBusiness
    {
        new T GetObject();
    }
    public class Foo 
    {
        public override string ToString()
        {
            return "I am a Foo";
        }
    }
    public class Bar
    {
        public override string ToString()
        {
            return "I am a Bar";
        }
    }
    public abstract class BaseBusiness<T> : IBaseBusiness<T>
    {
        public abstract T GetObject();
        object IBaseBusiness.GetObject()
        {
            return GetObject();
        }
    }
    public class FooBusiness : BaseBusiness<Foo>
    {
        public override Foo GetObject()
        {
            return new Foo();
        }
    }
    public class BarBusiness : BaseBusiness<Bar>
    {
        public override Bar GetObject()
        {
            return new Bar();
        }
    }
    public abstract class LazyLoadTest
    {
        protected abstract IBaseBusiness GetBusinessObject(Type theType);
        public void TestLazyLoad(string typnam)
        {
            IBaseBusiness business = GetBusinessObject(Type.GetType(typnam));
            Console.WriteLine(business.GetObject());
        }
    }
    public class CompanyEntityTest : LazyLoadTest
    {
          protected override IBaseBusiness GetBusinessObject(Type theType)
        {
              if(theType == typeof(Foo))
              {
                  return new FooBusiness();
              }
              else if(theType == typeof(Bar))
              {
                  return new BarBusiness();
              }
              else
              {
                  throw new Exception("No Foo or Bar");
              }
          }
    }
    public class Program
    {
        public static void Main(string[] args)
        {
            CompanyEntityTest cet = new CompanyEntityTest();
            cet.TestLazyLoad("E.Foo");
            cet.TestLazyLoad("E.Bar");
            Console.ReadKey();
        }
    }
}

using System;

namespace E
{
    public interface IBaseBusiness<T>
    {
        T GetObject();
    }
    public class Foo 
    {
        public override string ToString()
        {
            return "I am a Foo";
        }
    }
    public class Bar
    {
        public override string ToString()
        {
            return "I am a Bar";
        }
    }
    public class FooBusiness : IBaseBusiness<Foo>
    {
        public Foo GetObject()
        {
            return new Foo();
        }
    }
    public class BarBusiness : IBaseBusiness<Bar>
    {
        public Bar GetObject()
        {
            return new Bar();
        }
    }
    public abstract class LazyLoadTest
    {
        protected abstract IBaseBusiness<T> GetBusinessObject<T>();
        public void TestLazyLoad<T>()
        {
            IBaseBusiness<T> business = GetBusinessObject<T>();
            Console.WriteLine(business.GetObject());
        }
    }
    public class CompanyEntityTest : LazyLoadTest
    {
          protected override IBaseBusiness<T> GetBusinessObject<T>()
        {
              if(typeof(T) == typeof(Foo))
              {
                  return (IBaseBusiness<T>)new FooBusiness();
              }
              else if(typeof(T) == typeof(Bar))
              {
                  return (IBaseBusiness<T>)new BarBusiness();
              }
              else
              {
                  throw new Exception("No Foo or Bar");
              }
          }
    }
    public class Program
    {
        public static void Main(string[] args)
        {
            CompanyEntityTest cet = new CompanyEntityTest();
            cet.TestLazyLoad<Foo>();
            cet.TestLazyLoad<Bar>();
            Console.ReadKey();
        }
    }
}

using System;
using System.Reflection;

namespace E
{
    public interface IBaseBusiness<T>
    {
        T GetObject();
    }
    public class Foo 
    {
        public override string ToString()
        {
            return "I am a Foo";
        }
    }
    public class Bar
    {
        public override string ToString()
        {
            return "I am a Bar";
        }
    }
    public class FooBusiness : IBaseBusiness<Foo>
    {
        public Foo GetObject()
        {
            return new Foo();
        }
    }
    public class BarBusiness : IBaseBusiness<Bar>
    {
        public Bar GetObject()
        {
            return new Bar();
        }
    }
    public abstract class LazyLoadTest
    {
        protected abstract object GetBusinessObject(Type theType);
        public void TestLazyLoad(string typnam)
        {
            object business = GetBusinessObject(Type.GetType(typnam));
            object something = business.GetType().InvokeMember("GetObject", BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, business, new object[0]);
            Console.WriteLine(something);
        }
    }
    public class CompanyEntityTest : LazyLoadTest
    {
          protected override object GetBusinessObject(Type theType)
        {
              if(theType == typeof(Foo))
              {
                  return new FooBusiness();
              }
              else if(theType == typeof(Bar))
              {
                  return new BarBusiness();
              }
              else
              {
                  throw new Exception("No Foo or Bar");
              }
          }
    }
    public class Program
    {
        public static void Main(string[] args)
        {
            CompanyEntityTest cet = new CompanyEntityTest();
            cet.TestLazyLoad("E.Foo");
            cet.TestLazyLoad("E.Bar");
            Console.ReadKey();
        }
    }
}