public DerefResults( IWorker worker, IList<IWorker> workerList )
 {
     _worker = worker;
     _workerList = workerList;
     Debug.Assert( _worker == null || _workerList == null );
     Debug.Assert( _workerList == null || _workerList.Count > 0 );
 }

 public Scheduler(IPluginFinder plugins, IHeart heart, IWorker worker, IErrorNotifier errorHandler)
 {
     _actions = new List<ScheduledAction>(InstantiateActions(plugins));
     _heart = heart;
     _worker = worker;
     _errorHandler = errorHandler;
 }

        public ContentChangeTracker(IIndexer indexer, IPersister persister, IWorker worker, ConnectionMonitor connection, IErrorNotifier errors, DatabaseSection config)
        {
            this.indexer = indexer;
            this.persister = persister;
            this.worker = worker;
            this.errors = errors;
            this.async = config.Search.AsyncIndexing;
            this.handleErrors = config.Search.HandleErrors;

            RetryInterval = TimeSpan.FromMinutes(2);

            if(config.Search.Enabled)
            {
                connection.Online += delegate
                {
                    persister.ItemSaved += persister_ItemSaved;
                    persister.ItemMoving += persister_ItemMoving;
                    persister.ItemMoved += persister_ItemMoved;
                    persister.ItemCopied += persister_ItemCopied;
                    persister.ItemDeleted += persister_ItemDeleted;
                };
                connection.Offline += delegate
                {
                    persister.ItemSaved -= persister_ItemSaved;
                    persister.ItemMoving -= persister_ItemMoving;
                    persister.ItemMoved -= persister_ItemMoved;
                    persister.ItemCopied -= persister_ItemCopied;
                    persister.ItemDeleted -= persister_ItemDeleted;
                };
            }
        }

        public void Execute(IWorker[] workers, int runningSecs)
        {
            IAsyncResult[] ar = new IAsyncResult[workers.Length];
              int i = 0;
              foreach (IWorker w in workers) {
            w.WorkerID = i;
            ThreadStart t = new ThreadStart(w.DoWork);
            ar[i++] = t.BeginInvoke(null, null);
              }
              //for (int j = 0; j < runningSecs * 10; j++)
              //{
              //    Console.Write(".");
              //    Thread.Sleep(100);
              //}
              Thread.Sleep(runningSecs * 1000);
              Console.WriteLine();

              foreach (IWorker w in workers) {
            w.Running = false;
              }

              bool timeOut = false;
              foreach (IAsyncResult a in ar) {
              if (!a.IsCompleted)
              {
              if (!a.AsyncWaitHandle.WaitOne(1000))
                  timeOut = true;
              }
              }
              if (timeOut)
              Console.WriteLine("Timed Out!");
        }

 public AsyncTrashPurger(IWorker worker, ITrashHandler trash, IPersister persister, ISecurityManager security)
 {
     this.worker = worker;
     this.trash = trash;
     this.persister = persister;
     this.security = security;
 }

 public void setProperty(Identifier propName, IWorker worker)
 {
     throw new ClientException(
     String.Format(
         "attempted to set property '{0}' of a null value",
         propName));
 }

 public StockView(IWorker worker)
     : base(worker)
 {
     this.StockItemsCollection = new NotifiedObservableCollection<StockIngredientDTO>();
     this.RemovedStockItemsList = new List<StockIngredientDTO>();
     ResetIds();
 }

		public void Remove(IWorker worker)
		{
			lock (this.fSyncRoot)
			{
				worker.Done -= OnDone;
				base.Remove(worker);
			}
		}

		public void Add(IWorker worker)
		{
			lock (this.fSyncRoot)
			{
				worker.Done += OnDone;
				base.Add(worker);
			}
		}

 public ClientMainView(IWorker worker)
     : base(worker)
 {
     this.IngredientsCollection = new ObservableCollection<PizzaNetControls.IngredientsRow>();
     this.RecipesCollection = new ObservableCollection<PizzaNetControls.RecipeControl>();
     this.OrderedPizzasCollection = new ObservableCollection<IngredientsList>();
     this.Ingredients = new List<OrderIngredientDTO>();
 }

 public RedisBackend(IRedis redisClient, QueuedItem payload, Exception exception, IWorker worker, string queue)
 {
     RedisClient = redisClient;
     Payload = payload;
     Exception = exception;
     Worker = worker;
     Queue = queue;
 }

        protected BaseWorkerHost(IWorker worker)
        {
            worker.Require("worker");

            Worker = worker;

            Worker.ErrorOccurred += OnErrorOccurred;
            Worker.MessageOccurred += OnMessageOccurred;
        }

 public RecipiesView(IWorker worker)
     : base(worker)
 {
     this.IngredientsRowsCollection = new ObservableCollection<IngredientsRowWork>();
     this.RecipesCollection = new ObservableCollection<RecipeControl>();
     this.RemovedRecipes = new List<RecipeDTO>(5);
     SelectedRecipe = -1;
     Modified = false;
 }

 public static IWorker cast(IWorker source, IInterface face)
 {
     if( inheritsOrIs(source.face, face) )
     return castDown(source, face);
     source = source.owner.rootWorker;
     if( inheritsOrIs(source.face, face) )
     return castDown(source, face);
     throw new ClientException("the object does not implement this interface");
 }

 public Scheduler(IEngine engine, IPluginFinder plugins, IHeart heart, IWorker worker, IWebContext context, IErrorNotifier errorHandler)
 {
     this.engine = engine;
     actions = new List<ScheduledAction>(InstantiateActions(plugins));
     this.heart = heart;
     this.worker = worker;
     this.context = context;
     this.errorHandler = errorHandler;
 }

        public ParameterImpl(
	Direction direction, IType type,
	Identifier name, IWorker defaultValue )
        {
            _direction = direction;
            _type = type;
            _name = name;
            _defaultValue = defaultValue;
        }

		internal int RegisterRequest (IWorker worker)
		{
			int result = worker.GetHashCode ();
			lock (requests) {
				requests [result] = worker;
			}

			return result;
		}

 public Job(JobFactory creator, IFailureService failureService, IWorker worker, QueuedItem item,
            string queue)
 {
     Creator = creator;
     FailureService = failureService;
     Worker = worker;
     Payload = item;
     Queue = queue;
 }

 public static IWorker castDown(IWorker source, IInterface face)
 {
     Debug.Assert(inheritsOrIs(source.face, face));
     if( source.face == face )
     return source;
     foreach( IWorker child in source.childWorkers )
     if( inheritsOrIs(child.face, face) )
         return castDown(child, face);
     throw new ClientException("the object does not implement this interface");
 }

        public void AddWorker(IWorker worker)
        {
            if (_isRootInstance)
            {
                Thread workerThread = new Thread(RunWorker);
                workerThread.Start(worker);

                _workerThreads.Add(workerThread);
            }
        }