/// <summary>
		///   Initializes a new instance.
		/// </summary>
		/// <param name="createModel">Creates the model that should be checked.</param>
		/// <param name="output">The callback that should be used to output messages.</param>
		/// <param name="configuration">The analysis configuration that should be used.</param>
		internal ModelTraverser(Func<AnalysisModel> createModel, Action<string> output, AnalysisConfiguration configuration)
		{
			Requires.NotNull(createModel, nameof(createModel));
			Requires.NotNull(output, nameof(output));
			TransitionCollection.ValidateTransitionSizes();

			var tasks = new Task[configuration.CpuCount];
			var stacks = new StateStack[configuration.CpuCount];

			_loadBalancer = new LoadBalancer(stacks);
			Context = new TraversalContext(_loadBalancer, configuration, output);
			_workers = new Worker[configuration.CpuCount];

			for (var i = 0; i < configuration.CpuCount; ++i)
			{
				var index = i;
				tasks[i] = Task.Factory.StartNew(() =>
				{
					stacks[index] = new StateStack(configuration.StackCapacity);
					_workers[index] = new Worker(index, Context, stacks[index], createModel());
				});
			}

			Task.WaitAll(tasks);

			_states = new StateStorage(_workers[0].Model.StateVectorSize, configuration.StateCapacity);
			Context.States = _states;
		}

    public void Run()
    {
        const int num_workers = 4;
        Worker[] workers = new Worker[num_workers];
        Thread[] threads = new Thread[num_workers];

        for (int i = 0; i < num_workers; i++)
        {
            workers[i] = new Worker(i, 50);
            threads[i] = new Thread(workers[i].Run);
            threads[i].Start();
        }

        foreach (Thread t in threads)
            t.Join();

        foreach (Worker w in workers)
        {
            foreach (Expr e in w.result)
                Console.Write(" " + e);
            Console.WriteLine();
        }

        Console.WriteLine("done");
    }

    static void Main()
    {
        // 创建线程对象。这不会启动该线程。
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);

        // 启动辅助线程。
        workerThread.Start();
        Console.WriteLine("main thread: Starting worker thread...");

        // 循环直至辅助线程激活。
        while (!workerThread.IsAlive);

        // 为主线程设置 1 毫秒的休眠，
        // 以使辅助线程完成某项工作。
        Thread.Sleep(1);

        // 请求辅助线程自行停止：
        workerObject.RequestStop();

        // 使用 Join 方法阻塞当前线程，
        // 直至对象的线程终止。
        workerThread.Join();
        Console.WriteLine("main thread: Worker thread has terminated.");
    }

    internal void Enter(ref Worker wr, Work work) {
      work.Next = null;

      var owner = Interlocked.Exchange(ref Tail, work);

      if (owner != null) {
        owner.Next = work;
      } else {
      Release:
        work.DoWork(ref wr);
        var prev = work;
        work = Volatile.Read(ref prev.Next);
        if (null != work)
          goto Release;

        if (prev == Interlocked.CompareExchange(ref Tail, null, prev))
          return;

      Spin:
        work = Volatile.Read(ref prev.Next);
        if (null != work)
          goto Release;
        goto Spin;
      }
    }

        public static void Main()
        {
            string[] studentData = Console.ReadLine()
                .Trim()
                .Split(new []{' '}, StringSplitOptions.RemoveEmptyEntries);

            string firstStudentName = studentData[0];
            string lastStudentName = studentData[1];
            string facultyNumber = studentData[2];

            string[] workerData = Console.ReadLine()
                .Trim()
                .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            string firstWorkerName = workerData[0];
            string lastWorkerName = workerData[1];
            double salary = double.Parse(workerData[2]);
            double workingHours = double.Parse(workerData[3]);

            try
            {
                Student student = new Student(firstStudentName, lastStudentName, facultyNumber);
                Worker worker = new Worker(firstWorkerName, lastWorkerName, salary, workingHours);

                Console.WriteLine(student);
                Console.WriteLine(worker);
            }
            catch (ArgumentException ae)
            {
                Console.WriteLine(ae.Message);
            }
        }

		public static void Main(string[] args)
		{
			// Use Release Build to use jsc to generate java program
			// Use Debug Build to develop on .net

			Console.WriteLine("Robocode1. Crosscompiled from C# to Java.");

			// Extension methods...
			("This will take a few seconds...").ToConsole();

			Text = "Hello World";


			var w = new Worker { Count = 3, Delay = 1000 };

			w.Handler +=
				delegate
				{
					var n = DateTime.Now;

					Console.WriteLine(n.Hour + ":" + n.Minute + ":" + n.Second);
				};

			w.Invoke();

			Console.WriteLine(Text);
		}

    public static void Main()
	{
	    var worker = new Worker();
	    worker.Start();
	    Thread.Sleep(1000);
	    worker.Stop();	   
	}

 public void DoWork(Worker d)
 {
     if (!Thread.CurrentThread.Equals((object) this.myThread))
     this.app.Dispatcher.Invoke(DispatcherPriority.Normal, (Delegate) d);
       else
     d();
 }

        public void ConvertWorkerViewModel_WhenValidViewModel_ReturnEntity()
        {
            var adrConv = new AddressConverter();
            var compConv = new CompetenceConverter();
            var converter = new WorkerConverter(adrConv,compConv,new ImageConverter());

            var viewModel = new WorkerViewModel
            {
                FirstName = "Filip",
                LastName = "Skurniak",
                Pesel = "632964328947",
                RelianceRating = 10,
                WorkerCompetences = new List<CompetenceViewModel>()
                {
                    new CompetenceViewModel
                    {
                        Id = 100
                    }
                }
            };
            var entity = new Worker();

            converter.ConvertViewModelToEntity(viewModel, entity);

            Assert.AreEqual(entity.FirstName, viewModel.FirstName);
        }

 public override void Invoke(Worker.State state)
 {
     foreach (char ch in text)
     {
         TypeChar(ch);
     }
 }

 static void Main(string[] args)
 {
     using (var worker = new Worker("localhost", "console", "failing"))
     {
         worker.Work();
     }
 }

 protected Backend(Object payload, Exception exception, Worker worker, String queue)
 {
     Exception = exception;
     Worker = worker;
     Queue = queue;
     Payload = payload;
 }

        public override Worker AsWorker()
        {
            Worker worker = new Worker("OTT", "Mathias Henrik Ottosen", 18, true, "Aalborg", "12345678", false, true, true);

            worker.SetNotAvailableHours(AsIndisposeds());
            return worker;
        }

        public override void Invoke(Worker.State state)
        {
            INPUT[] queue = new INPUT[1];
            queue[0] = new INPUT();

            queue[0].type = InputType.Mouse;

            switch (button)
            {
                case MouseButtons.Left:
                    queue[0].u.Mouse.Flags |= MouseFlag.LeftUp;
                    break;
                case MouseButtons.Right:
                    queue[0].u.Mouse.Flags |= MouseFlag.RightUp;
                    break;
                case MouseButtons.Middle:
                    queue[0].u.Mouse.Flags |= MouseFlag.MiddleUp;
                    break;
                case MouseButtons.XButton1:
                    queue[0].u.Mouse.Flags |= MouseFlag.XUp;
                    queue[0].u.Mouse.MouseData |= (ushort)XButton.XButton1;
                    break;
                case MouseButtons.XButton2:
                    queue[0].u.Mouse.Flags |= MouseFlag.XUp;
                    queue[0].u.Mouse.MouseData |= (ushort)XButton.XButton2;
                    break;
            }
            NativeMethods.SendInput(1, queue, Marshal.SizeOf(typeof(INPUT)));
        }

        public FormLoader(Plugin plugin, RecordReader stockReader, bool lazyLoading, int backgroundJobs)
        {
            if (backgroundJobs < 0)
                throw new ArgumentException("Number of bakcground jobs must be a positive integer or zero");

            sharedData = new SharedData()
            {
                Plugin = plugin,
                StockReader = stockReader,
                LazyLoading = lazyLoading,
                FormsToLoad = new BlockingCollection<Form>(new ConcurrentQueue<Form>(), 1024),
                WorkerCompleteEvent = new AutoResetEvent(false)
            };

            this.stockReader = stockReader;
            asyncLoading = backgroundJobs > 0;

            bool useStockReader = true;
            while (backgroundJobs-- > 0)
            {
                Worker worker = new Worker(sharedData, useStockReader);
                worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
                worker.RunWorkerAsync();
                workers.Add(new WorkerInfo()
                {
                    Worker = worker
                });

                // Only the first worker can use the stock reader
                useStockReader = false;
            }
        }

        public MainServer(IPEndPoint a_bindAddr_tcp1,
						  IPEndPoint a_bindAddr_tcp2,
						  IPEndPoint a_subServer_tcp,
						  IPEndPoint a_bindAddr_udp1,
						  IPEndPoint a_bindAddr_udp2,
						  IPEndPoint a_subServer_udp)
        {
            bool nullArg = a_bindAddr_tcp1 == null
                        || a_bindAddr_tcp2 == null
                        || a_subServer_tcp == null
                        || a_bindAddr_udp1 == null
                        || a_bindAddr_udp2 == null
                        || a_subServer_udp == null;
            if (nullArg)
                throw new ArgumentNullException();

            m_firstTcp = new Worker(ProtocolType.Tcp, a_bindAddr_tcp1, FirstWorkerRoutine);
            m_firstUdp = new Worker(ProtocolType.Udp, a_bindAddr_udp1, FirstWorkerRoutine);

            m_secondTcp = new Worker(ProtocolType.Tcp, a_bindAddr_tcp2, SecondWorkerRoutine);
            m_secondUdp = new Worker(ProtocolType.Udp, a_bindAddr_udp2, SecondWorkerRoutine);

            m_subServerAddr_tcp = a_subServer_tcp;
            m_subServerAddr_udp = a_subServer_udp;

            m_subServerTcp = new Worker(ProtocolType.Tcp, null, HeartbeatRoutine);
            m_subServerUdp = new Worker(ProtocolType.Udp, null, HeartbeatRoutine);
        }

  public static int Main ()
  {
    Console.WriteLine ("Input file: ");
    string filename = Console.ReadLine ();
    int[] input;

    using (StreamReader sr = new StreamReader (filename)) {
      int noElements = Int32.Parse (sr.ReadLine ());
      input = new int[noElements];
      for (int i = 0; i < noElements; i++) {
        input [i] = Int32.Parse (sr.ReadLine ());
      }
    }

    Worker[] workers = new Worker[10];

    Thread[] threads;

    // Start the thread
    //threadx.Start ();

    // Waiting for thread to become alive
    //while (!threadx.IsAlive);

    // In miliseconds
    Thread.Sleep (1);

    // Stop threadx
    //threadx.Abort ();

    //threadx.Join ();
    return 0;
  }

 public void Execute(Worker worker)
 {
     if (!worker.IsOnBoard)
     {
         throw new NotImplementedException();
     }
 }

    static void Main()
    {
        // load settings from App.config
        int numThreads = int.Parse(ConfigurationManager.AppSettings["numThreads"]);
        int waitTimeMillisecs = int.Parse(ConfigurationManager.AppSettings["waitTimeMillisecs"]);
        int iterations = int.Parse(ConfigurationManager.AppSettings["iterations"]);

        List<Worker> workers = new List<Worker>();

        for (int i = 0; i < numThreads; i++)
        {
            Worker worker = new Worker(iterations, waitTimeMillisecs);
            workers.Add(worker);
            ThreadStart job = new ThreadStart(worker.Run);
            Thread t = new Thread(job);
            t.Start();
        }

        long numIterations = 0;

        while (numIterations < (iterations * numThreads))
        {
            numIterations = 0;

            foreach (Worker worker in workers)
            {
                numIterations += worker.NumIterations;
            }

            Console.WriteLine("Iterations: {0}", numIterations);

            Thread.Sleep(500);
        }
    }

 public Backend(Exception exception, Worker worker, String queue, Object payload)
 {
     this.exception = exception;
     this.worker = worker;
     this.queue = queue;
     this.payload = payload;
 }