//--------------------------------------
 // INITIALIZE
 //--------------------------------------
 public CEvent(int id, string name, object data, IDispatcher dispatcher)
 {
     _id = id;
     _name = name;
     _data = data;
     _dispatcher = dispatcher;
 }

 public LoadSolutionsCommand(SolutionsLauncherViewModel solutionsLauncherViewModel, ISolutionDetector solutionDetector, ISolutionPriorityResolver solutionPriorityResolver, IDispatcher dispatcher)
 {
     _solutionsLauncherViewModel = solutionsLauncherViewModel;
     _solutionDetector = solutionDetector;
     _solutionPriorityResolver = solutionPriorityResolver;
     _dispatcher = dispatcher;
 }

        public Publisher(PublisherSettings settings, IHandlerSource handlerSource, IDispatcher[] dispatchers)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }
            if (handlerSource == null)
            {
                throw new ArgumentNullException("handlerSource");
            }

            if (dispatchers == null)
            {
                throw new ArgumentNullException("dispatchers");
            }

            if (dispatchers.Any(x => ReferenceEquals(x, null)))
            {
                throw new ArgumentException("At least one of dispatches is null.", "dispatchers");
            }

            _settings = settings;
            _handlerSource = handlerSource;
            _dispatchers = dispatchers;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="UnmanagedBitmapRenderer" /> class.
 /// </summary>
 /// <param name="threadManager">The thread manager.</param>
 /// <param name="dispatcher">The dispatcher.</param>
 public UnmanagedBitmapRenderer(IThreadManager threadManager, IDispatcher dispatcher)
     : base(threadManager)
 {
     threadManager.Guard("threadManager");
     dispatcher.Guard("dispatcher");
     this.dispatcher = dispatcher;
 }

 public MemoryImageViewModel(IGameBoy gameBoy, IDispatcher dispatcher)
 {
     _gameBoy = gameBoy;
       _dispatcher = dispatcher;
       _gameBoy.FrameCompleted += OnFrameCompleted;
       _memoryImage = new WriteableBitmap(256, 256, 96, 96, PixelFormats.Gray8, null);
 }

		///this btDiscreteDynamicsWorld constructor gets created objects from the user, and will not delete those
		public DiscreteDynamicsWorld(IDispatcher dispatcher, IBroadphaseInterface pairCache, IConstraintSolver constraintSolver, ICollisionConfiguration collisionConfiguration)
			: base(dispatcher, pairCache, collisionConfiguration)
		{
			m_ownsIslandManager = true;
			m_constraints = new ObjectArray<TypedConstraint>();
			m_actions = new List<IActionInterface>();
			m_nonStaticRigidBodies = new ObjectArray<RigidBody>();
			m_islandManager = new SimulationIslandManager();
			m_constraintSolver = constraintSolver;

			Gravity = new Vector3(0, -10, 0);
			m_localTime = 1f / 60f;
			m_profileTimings = 0;
			m_synchronizeAllMotionStates = false;

			if (m_constraintSolver == null)
			{
				m_constraintSolver = new SequentialImpulseConstraintSolver();
				m_ownsConstraintSolver = true;
			}
			else
			{
				m_ownsConstraintSolver = false;
			}
		}

 public Acceptor(TcpListener listener, IDispatcher dispatcher)
 {
     _listener = listener;
     _listener.Start();
     _dispatcher = dispatcher;
     _dispatcher.Register(this);
 }

 public DynamicsWorld(IDispatcher dispatcher, IBroadphaseInterface broadphase, ICollisionConfiguration collisionConfiguration)
     : base(dispatcher, broadphase, collisionConfiguration)
 {
     InternalTickCallback = null;
     InternalPreTickCallback = null;
     m_worldUserInfo = null;
 }

        internal MethodEntityProcessor(MethodEntity methodEntity, 
            IDispatcher dispatcher, ICodeProvider codeProvider, IEntityDescriptor entityDescriptor = null,
            bool verbose = false)
            : base(methodEntity, entityDescriptor, dispatcher)
        {
            Contract.Assert(methodEntity != null);

            this.MethodEntity = methodEntity;
            this.EntityDescriptor = entityDescriptor==null?methodEntity.EntityDescriptor
                                                          :entityDescriptor;
            this.Verbose = true; // verbose;
            // It gets a code provider for the method.
            if (codeProvider!=null || dispatcher is OrleansDispatcher)
            {
                this.codeProvider = codeProvider;
                 //this.codeProvider = ProjectGrainWrapper.CreateProjectGrainWrapperAsync(methodEntity.MethodDescriptor).Result;
                //SetCodeProviderAsync(methodEntity.MethodDescriptor);
            }
            else
            {
                var pair = ProjectCodeProvider.GetProjectProviderAndSyntaxAsync(methodEntity.MethodDescriptor).Result;
                if (pair != null)
                {
                    this.codeProvider = pair.Item1;
                }
            }
            // We use the codeProvider for Propagation and HandleCall and ReturnEvents (in the method DiffProp that uses IsAssignable)
            // We can get rid of this by passing codeProvider as parameter in this 3 methods
            this.MethodEntity.PropGraph.SetCodeProvider(this.codeProvider);
        }

 public APUViewModel(IGameBoy gameBoy, IDispatcher dispatcher)
 {
     _gameBoy = gameBoy;
       _dispatcher = dispatcher;
       _gameBoy.FrameCompleted += OnFrameCompleted;
       _spectrogram = new WriteableBitmap(_numberOfFramesPerImage, _fftSize, 96, 96, PixelFormats.Bgr32, null);
 }

        public DatabaseFileStorage(IDispatcher dispatcher)
        {
            if (dispatcher == null)
                throw new ArgumentNullException(nameof(dispatcher));

            _dispatcher = dispatcher;
        }

        public ComponentDetailViewModel(string componentId, IDispatcher dispatcher, IActiveItemRepository<Component> components)
        {
            dispatcher.Background(() =>
            {
                Component component;
                if (!components.TryGetItem(componentId, out component))
                    throw new ArgumentException("Unknown component.");

                var description = component.Description;
                var services = component.DescribeServices();
                var metadata = component.Metadata;
                var sharing = component.Sharing;
                var lifetime = component.Lifetime;
                var activator = component.Activator;
                var ownership = component.Ownership;
                var target = component.TargetComponentId;
                var id = component.Id;

                dispatcher.Foreground(() =>
                {
                    Description = description;
                    Metadata = metadata;
                    Services = services;
                    Sharing = sharing.ToString();
                    Lifetime = lifetime.ToString();
                    Activator = activator.ToString();
                    Ownership = ownership.ToString();
                    Target = target;
                    Id = id;
                });
            });
        }

		public Object RemoveOverlappingPair(BroadphaseProxy proxy0, BroadphaseProxy proxy1, IDispatcher dispatcher)
		{
			if (!HasDeferredRemoval())
			{
				BroadphasePair findPair = new BroadphasePair(proxy0,proxy1);

				int findIndex = m_overlappingPairArray.IndexOf(findPair);
				if (findIndex >= 0 && findIndex < m_overlappingPairArray.Count)
				{
					OverlappingPairCacheGlobals.gOverlappingPairs--;
					BroadphasePair pair = m_overlappingPairArray[findIndex];
					Object userData = pair.m_internalInfo1;
					CleanOverlappingPair(pair,dispatcher);
					if (m_ghostPairCallback != null)
					{
						m_ghostPairCallback.RemoveOverlappingPair(proxy0, proxy1,dispatcher);
					}
					//BroadphasePair temp = m_overlappingPairArray[findIndex];
					//m_overlappingPairArray[findIndex] = m_overlappingPairArray[m_overlappingPairArray.Count-1];
					//m_overlappingPairArray[m_overlappingPairArray.Count-1] = temp;
					m_overlappingPairArray.RemoveAt(m_overlappingPairArray.Count - 1);
					return userData;
				}
			}

			return 0;
		}

 public QueueSubscriptionFactory( ISubscriptionManager subscriptions, IDispatcher dispatcher,
                                  IChannelProxyFactory proxyFactory )
 {
     Subscriptions = subscriptions;
     Dispatcher = dispatcher;
     ProxyFactory = proxyFactory;
 }

		public MyNodeOverlapCallback(MultiSapBroadphase multiSap,MultiSapProxy multiProxy,IDispatcher dispatcher)
		{
			m_multiSap = multiSap;
			m_multiProxy = multiProxy;
			m_dispatcher = dispatcher;

		}

		/// <summary>
		/// this btSimpleDynamicsWorld constructor creates dispatcher, broadphase pairCache and constraintSolver
		/// </summary>
		/// <param name="dispatcher"></param>
		/// <param name="pairCache"></param>
		/// <param name="constraintSolver"></param>
		public SimpleDynamicsWorld(IDispatcher dispatcher, OverlappingPairCache pairCache, IConstraintSolver constraintSolver)
			: base(dispatcher, pairCache)
		{
			_constraintSolver = constraintSolver;
			_ownsConstraintSolver = false;
			_gravity = new Vector3(0, 0, -10);
		}

		public DynamicsWorld(IDispatcher dispatcher,IBroadphaseInterface broadphase,ICollisionConfiguration collisionConfiguration)
		:base(dispatcher,broadphase,collisionConfiguration)
		{
            m_internalTickCallback = null;
            m_worldUserInfo = null;
            m_solverInfo = new ContactSolverInfo();
		}

        public BroadphaseProxy createProxy(ref btVector3 aabbMin,ref btVector3 aabbMax,
            BroadphaseNativeTypes shapeType, object userPtr,
            short collisionFilterGroup, short collisionFilterMask, IDispatcher dispatcher,
            object multiSapProxy)
        {

            DbvtProxy proxy = new DbvtProxy(aabbMin, aabbMax, userPtr,
                collisionFilterGroup,
                collisionFilterMask);

            DbvtAabbMm aabb;// = DbvtAabbMm.FromMM(aabbMin, aabbMax);
            DbvtAabbMm.FromMM(ref aabbMin, ref aabbMax, out aabb);

            //bproxy->aabb			=	btDbvtVolume::FromMM(aabbMin,aabbMax);
            proxy.stage = m_stageCurrent;
            proxy.m_uniqueId = ++m_gid;
            proxy.leaf = m_sets[0].insert(ref aabb, proxy);
            listappend(ref proxy, ref m_stageRoots[m_stageCurrent]);
            if (!m_deferedcollide)
            {
                DbvtTreeCollider collider = new DbvtTreeCollider(this);
                collider.proxy = proxy;
                m_sets[0].collideTV(m_sets[0].m_root, ref aabb, collider);
                m_sets[1].collideTV(m_sets[1].m_root,ref aabb, collider);
            }
            return (proxy);
        }

        public ViewModelBase(IPersonService personService, IDispatcher dispatcher, IEventAggregator aggregator, IDialogService dialogService)
        {
            if (personService == null)
            {
                throw new ArgumentNullException("personService");
            }

            if (dispatcher == null)
            {
                throw new ArgumentNullException("dispatcher");
            }

            if (aggregator == null)
            {
                throw new ArgumentNullException("aggregator");
            }

            if (dialogService == null)
            {
                throw new ArgumentNullException("dialogService");
            }

            this.personService = personService;
            this.dispatcher = dispatcher;
            this.aggregator = aggregator;
            this.dialogService = dialogService;

            isBusy = false;
        }

        public SolverService(
            [NotNull] IMessageBus messageBus,
            [NotNull] IGameService gameService,
            [NotNull] IBoardSolverService boardSolverService,
            [NotNull] IDispatcher dispatcher)
        {
            if (messageBus == null)
            {
                throw new ArgumentNullException(nameof(messageBus));
            }

            if (gameService == null)
            {
                throw new ArgumentNullException(nameof(gameService));
            }

            if (boardSolverService == null)
            {
                throw new ArgumentNullException(nameof(boardSolverService));
            }

            if (dispatcher == null)
            {
                throw new ArgumentNullException(nameof(dispatcher));
            }

            this.messageBus = messageBus;
            this.gameService = gameService;
            this.boardSolverService = boardSolverService;
            this.dispatcher = dispatcher;

            this.messageBus.Subscribe<BoardScrambled>(this.OnBoardScrambled);
            this.messageBus.Subscribe<BoardResetted>(this.OnBoardResetted);
            this.messageBus.Subscribe<SlideHappened>(this.OnSlideHappened);
        }