public IWorkResult Execute(IWorkItem workItem)
        {
            var workResult = new MatrixMultiplicationWorkResult();
            workResult.Success = false;

            try
            {
                var concreteWorkItem = workItem as MatrixMultiplicationWorkItem;

                if (concreteWorkItem != null)
                {
                    workResult.Result = concreteWorkItem.GridAValue * concreteWorkItem.GridBValue;
                    workResult.Success = true;
                }
                else
                {
                    workResult.Error = new ArgumentNullException(string.Concat("The workItem was either null or could not be cast to a instance of ", typeof(MatrixMultiplicationWorkItem).Name));
                }

            }
            catch (Exception e)
            {
                workResult.Error = e;
            }

            return workResult;
        }

 public override ScopeMatchResult Matches(IWorkItem item)
 {
     var res = new ScopeMatchResult();
     res.Add(item.TypeName);
     res.Success = this.ApplicableTypes.Any(type => type.SameAs(item.TypeName));
     return res;
 }

        private static WorkItemRepositoryMock MakeRepository(out IWorkItem startPoint)
        {
            var repository = new WorkItemRepositoryMock();

            var grandParent = new WorkItemMock(repository);
            grandParent.Id = 1;
            grandParent.TypeName = "Feature";

            var parent = new WorkItemMock(repository);
            parent.Id = 2;
            parent.TypeName = "Use Case";

            var firstChild = new WorkItemMock(repository);
            firstChild.Id = 3;
            firstChild.TypeName = "Task";
            var secondChild = new WorkItemMock(repository);
            secondChild.Id = 4;
            secondChild.TypeName = "Task";

            firstChild.WorkItemLinks.Add(new WorkItemLinkMock(WorkItemImplementationBase.ParentRelationship, parent.Id, repository));
            secondChild.WorkItemLinks.Add(new WorkItemLinkMock(WorkItemImplementationBase.ParentRelationship, parent.Id, repository));
            parent.WorkItemLinks.Add(new WorkItemLinkMock(WorkItemImplementationBase.ParentRelationship, grandParent.Id, repository));

            grandParent.WorkItemLinks.Add(new WorkItemLinkMock(WorkItemImplementationBase.ChildRelationship, parent.Id, repository));
            parent.WorkItemLinks.Add(new WorkItemLinkMock(WorkItemImplementationBase.ChildRelationship, firstChild.Id, repository));
            parent.WorkItemLinks.Add(new WorkItemLinkMock(WorkItemImplementationBase.ChildRelationship, secondChild.Id, repository));

            repository.SetWorkItems(new[] { grandParent, parent, firstChild, secondChild });

            startPoint = grandParent;
            return repository;
        }

 /// <summary>
 /// Notification of failure
 /// </summary>
 /// <param name="workItem">Work item that failed</param>
 /// <param name="failureInfo">Failure information (usually exception)</param>
 public void WorkFailed( IWorkItem workItem, object failureInfo )
 {
     foreach ( IWorkItemProgressMonitor monitor in m_Monitors )
     {
         monitor.WorkFailed( workItem, failureInfo );
     }
 }

 /// <summary>
 /// Notification of work completion
 /// </summary>
 /// <param name="workItem">Work item that completed</param>
 public void WorkComplete( IWorkItem workItem )
 {
     foreach ( IWorkItemProgressMonitor monitor in m_Monitors )
     {
         monitor.WorkComplete( workItem );
     }
 }

 /// <summary>
 /// Notification of work completion
 /// </summary>
 /// <param name="workItem">Work item that completed</param>
 public void WorkComplete( IWorkItem workItem )
 {
     if ( m_WorkQueue.NumberOfWorkItemsInQueue == 0 )
     {
         Close( );
     }
 }

 /// <summary>
 /// İşçi Thread'i iş parçası işini bitirdi olay argümanları inşacı metodu.
 /// </summary>
 /// <param name="workItem">İş parçası nesnesi.</param>
 public WorkerThreadWorkItemFinishedEventArgs(IWorkItem workItem)
 {
     if (workItem == null)
     {
         throw new ArgumentNullException("workItem");
     }
     WorkItem = workItem;
 }

 /// <summary>
 /// Notification of progress in a work item
 /// </summary>
 /// <param name="workItem">Work item that has progressed</param>
 /// <param name="progress">Normalized progress</param>
 /// <returns>Returns true if the process should continue, false if the process should cancel.</returns>
 public bool UpdateProgress( IWorkItem workItem, float progress )
 {
     bool cancel = false;
     foreach ( IWorkItemProgressMonitor monitor in m_Monitors )
     {
         cancel |= !monitor.UpdateProgress( workItem, progress );
     }
     return !cancel;
 }

        public override bool Matches(IWorkItem item)
        {
            var trigger = this.FieldNames;

            var fields = item.Fields.ToArray();
            var available = fields.Select(f => f.Name).Concat(fields.Select(f => f.ReferenceName));

            return trigger.All(t => available.Contains(t, StringComparer.OrdinalIgnoreCase));
        }

        public IWorkItem MakeNewWorkItem(IWorkItem inSameProjectAs, string workItemTypeName)
        {
            if (inSameProjectAs == null)
            {
                throw new ArgumentNullException(nameof(inSameProjectAs));
            }

            return this.MakeNewWorkItem(workItemTypeName, inSameProjectAs[CoreFieldReferenceNames.TeamProject] as string);
        }

        /// <summary>
        /// İşçi Thread havuzu yeni bir iş parçasını iş parcası kuyruğuna sokuyor olay argümanları sınıfı inşacı metodu.
        /// </summary>
        /// <param name="workItem">İş parçası.</param>
        public WorkerThreadPoolEnqueuingNewWorkItemEventArgs(IWorkItem workItem)
        {
            if (workItem == null)
            {
                throw new ArgumentNullException("workItem");
            }

            m_WorkItem = workItem;
        }

    public void Add(IWorkItem item_)
    {
      if (item_ == null) return;

      lock (m_queue)
        m_queue.Enqueue(item_);

      m_autoResetEvent.Set();
    }

        public static void TransitionToState(IWorkItem workItem, string state, string commentPrefix, ILogEvents logger)
        {
            // Set the sourceWorkItem's state so that it is clear that it has been moved.
            string originalState = (string)workItem.Fields["State"].Value;

            // Try to set the state of the source work item to the "Deleted/Moved" state (whatever is defined in the file).

            // We need an open work item to set the state
            workItem.TryOpen();

            // See if we can go directly to the planned state.
            workItem.Fields["State"].Value = state;

            if (workItem.Fields["State"].Status != FieldStatus.Valid)
            {
                // Revert back to the original value and start searching for a way to our "MovedState"
                workItem.Fields["State"].Value = workItem.Fields["State"].OriginalValue;

                // If we can't then try to go from the current state to another state.  Saving each time till we get to where we are going.
                foreach (string curState in FindNextState(workItem.Type, (string)workItem.Fields["State"].Value, state))
                {
                    string comment;
                    if (curState == state)
                    {
                        comment = string.Format(
                            "{0}{1}  State changed to {2}",
                            commentPrefix,
                            Environment.NewLine,
                            state);
                    }
                    else
                    {
                        comment = string.Format(
                            "{0}{1}  State changed to {2} as part of move toward a state of {3}",
                            commentPrefix,
                            Environment.NewLine,
                            curState,
                            state);
                    }

                    bool success = ChangeWorkItemState(workItem, originalState, curState, comment, logger);

                    // If we could not do the incremental state change then we are done.  We will have to go back to the original...
                    if (!success)
                    {
                        break;
                    }
                }
            }
            else
            {
                // Just save it off if we can.
                string comment = commentPrefix + "\n   State changed to " + state;
                ChangeWorkItemState(workItem, originalState, state, comment, logger);
            }
        }

 public void Enqueue(IWorkItem item)
 {
     var priority = (int)item.Priority;
     if (priority >= _queues.Count)
     {
         throw new ArgumentException(string.Format("Invalid TaskItemPriority: {0}", item.Priority));
     }
     _queues[priority].Enqueue(item);
     _workItemCount++;
 }

 /// <summary>
 /// Add a task object to the test queue.  For a test that is currently 
 /// executing, all tasks contained within the queue are executed to 
 /// completion (unless an Exception is thrown) -before- moving on to 
 /// the next test.
 /// 
 /// The test task queue replaces the PumpMessages(...) system that 
 /// permitted a single callback.  This enables specialized tasks, such 
 /// as DOM bridge tasks, sleep tasks, and conditional continue tasks.
 /// </summary>
 /// <param name="testTaskObject">Asynchronous test task 
 /// instance.</param>
 public virtual void EnqueueWorkItem(IWorkItem testTaskObject)
 {
     if (UnitTestHarness.DispatcherStack.CurrentCompositeWorkItem != null)
     {
         UnitTestHarness.DispatcherStack.CurrentCompositeWorkItem.Enqueue(testTaskObject);
     }
     else
     {
         throw new InvalidOperationException(Properties.UnitTestMessage.WorkItemTest_EnqueueWorkItem_AsynchronousFeatureUnavailable);
     }
 }

 protected override void EnqueueCore(IWorkItem item)
 {
     lock (_locker)
     {
         _taskQueue.Enqueue(item);
         if (_consumersWaiting > 0)
         {
             Monitor.PulseAll(_locker);
         }
     }
 }

        public bool Setup(string serverType, string bootstrapUri, string assemblyImportRoot, IServerConfig config, ProviderFactoryInfo[] factories)
        {
            m_AssemblyImporter = new AssemblyImport(assemblyImportRoot);

            var serviceType = Type.GetType(serverType);
            m_AppServer = (IWorkItem)Activator.CreateInstance(serviceType);

            var bootstrap = (IBootstrap)Activator.GetObject(typeof(IBootstrap), bootstrapUri);

            return m_AppServer.Setup(bootstrap, config, factories);
        }

 private static void RunWorkItemTask(IWorkItem todo, TaskScheduler sched)
 {
     try
     {
         RuntimeContext.SetExecutionContext(todo.SchedulingContext, sched);
         todo.Execute();
     }
     finally
     {
         RuntimeContext.ResetExecutionContext();
     }
 }

        public PerformanceMonitor(IRootConfig config, IEnumerable<IWorkItem> appServers, IWorkItem serverManager, ILogFactory logFactory)
        {
            m_PerfLog = logFactory.GetLog("Performance");

            m_AppServers = appServers.ToArray();

            m_ServerManager = serverManager;

            m_Helper = new ProcessPerformanceCounterHelper(Process.GetCurrentProcess());

            m_TimerInterval = config.PerformanceDataCollectInterval * 1000;
            m_PerformanceTimer = new Timer(OnPerformanceTimerCallback);
        }

        public override ScopeMatchResult Matches(IWorkItem item)
        {
            var res = new ScopeMatchResult();

            var trigger = this.FieldNames;

            var fields = item.Fields.ToArray();
            var available = fields.Select(f => f.Name).Concat(fields.Select(f => f.ReferenceName));

            res.AddRange(available);
            res.Success = trigger.All(t => available.Contains(t, StringComparer.OrdinalIgnoreCase));

            return res;
        }