Download source files:
http://www.jkofsp.net/files/

multi managerによって複数のサブシステムを切り替えることができます

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Takaku.Simulation.MultiMgr
{
   public interface ICached
   {
       void Flush();
   }

   public class ManagerCached
   {
       private LinkedList<ICached> Cacheds = new LinkedList<ICached>();
       public void Add(ICached cached)
       {
           Cacheds.AddLast(cached);
       }
       public void Remove(ICached cached)
       {
           Cacheds.Remove(cached);
       }
       public void Flush()
       {
           foreach(ICached i in Cacheds)
               i.Flush();
       }
   }

   public class Cached<T> : ICached
   {
       private Func<T> FuncValue;
       private T Value;
       private bool Calculated;
       public Cached(ManagerCached mgr, Func<T> funcValue)
       {
           FuncValue = funcValue;
           Calculated = false;
           mgr.Add(this);
       }
       public void Remove(ManagerCached mgr)
       {
           mgr.Remove(this);
       }
       public T v()
       {
           if (Calculated)
               return Value;
           else
           {
               Calculated = true;
               return Value = FuncValue();
           }
       }
public static implicit operator T(Cached<T> x){ return x.v(); }
       public void Flush()
       {
           Calculated = false;
       }
   }

   public interface IState
{
void Update();
void Flush();
}

   public class ManagerState
   {
   private LinkedList<IState> States = new LinkedList<IState>();
   public void Add(IState state)
   {
   States.AddLast(state);
   }
   public void Remove(IState state)
   {
   States.Remove(state);
   }
       public void Update()
       {
           foreach(IState i in States)
       i.Update();
       }
   public void Flush()
   {
   foreach(IState i in States)
       i.Flush();
   }
   }

   public class State<T> : IState
   {
       private Func<T,T> FuncState;
       private T Current, Next;
       public State(ManagerState mgr, T defaultValue, Func<T,T> funcState)
       {
           Current = defaultValue;
           FuncState = funcState;
           mgr.Add(this);
       }
       public void Remove(ManagerState mgr)
       {
           mgr.Remove(this);
       }
       public T v()
       {
           return Current;
       }
public static implicit operator T(State<T> x){ return x.v(); }
       public void Update()
       {
           Next = FuncState(Current);
       }
       public void Flush()
       {
           Current = Next;
       }
   }

   public interface IDiff
   {
   void Update();
   }

   public class ManagerDiff
   {
   private LinkedList<IDiff> Diffs = new LinkedList<IDiff>();
   public void Add(IDiff diff)
   {
   Diffs.AddLast(diff);
   }
       public void Remove(IDiff diff)
       {
           Diffs.Remove(diff);
       }
   public void Update()
   {
   foreach (IDiff i in Diffs)
   i.Update();
   }
   }

   public class Diff<T> : IDiff
   {
public static Func<T, T, T> FuncSub;

       private Func<T> FuncValue;
       private T Old, _d;
       public Diff(ManagerDiff mgr, T defaultValue, Func<T> funcValue)
       {
           Old = defaultValue;
           FuncValue = funcValue;
           mgr.Add(this);
       }
       public void Remove(ManagerDiff mgr)
       {
           mgr.Remove(this);
       }
       public T d()
       {
           return _d;
       }
public static implicit operator T(Diff<T> x){ return x.d(); }
       public void Update()
       {
           T _new = FuncValue();
           _d = FuncSub(_new, Old);
           Old = _new;
       }
   }

   public interface IDual
   {
       void Flush();
   }

   public class ManagerDual
   {
       private LinkedList<IDual> Duals = new LinkedList<IDual>();
       public void Add(IDual dual)
       {
           Duals.AddLast(dual);
       }
       public void Remove(IDual dual)
       {
           Duals.Remove(dual);
       }
       public void Flush()
       {
           foreach (IDual i in Duals)
               i.Flush();
       }
   }

   public class Dual<T> : IDual
   {
       private T _Current, _Next;
       public Dual(ManagerDual mgr, T defaultValue)
       {
           _Current = defaultValue;
           mgr.Add(this);
       }
       public void Remove(ManagerDual mgr)
       {
           mgr.Remove(this);
       }
       public T Current
       {
           get
           {
               return _Current;
           }
       }
       public T Next
       {
           set
           {
               _Next = value;
           }
       }
       public void Flush()
       {
           _Current = _Next;
       }
   }

   public interface ISimulationRemovable
   {
   void RemoveSimulation();
   }

public delegate T Bind<T>();
}