C# Worker.DoWork方法代码示例

        static void Main(string[] args)
        {
            Worker worker = new Worker();

            //worker.BadDoWork();
            worker.DoWork();

            Console.ReadKey();
        }

 public override bool Execute()
 {
     try
     {
         var worker = new Worker();
         worker.DoWork(this, this);
         return true;
     }
     catch (Exception exception)
     {
         Log.LogErrorFromException(exception);
         return false;
     }
 }

        private void ApiThread()
        {
            // Start the Selfhosted WebAPI. Read the apiUrl from the config file
            var listenUrl = ConfigurationManager.AppSettings["ApiUrl"];
            Console.WriteLine("Launching WebAPI at " + listenUrl);
            // If this line generates an error, you can use the netsh command to allow the port to be listened on by non-administrators
            // Source: http://stackoverflow.com/questions/3682287/why-wont-my-windows-service-that-is-hosting-a-wcf-service-run-under-localservic
            // Example: netsh http add urlacl url=http://*:9999/ user=Everyone

            using (WebApp.Start<Startup>(listenUrl))
            {
                isRunning = true;

                // Keep the thread alive so that application doesn't exit
                var worker = new Worker();
                while (serviceStarted)
                {
                    worker.DoWork();
                    Thread.Sleep(100);
                }
            }
            isRunning = false;
        }

        /* Can't derive from sealed class.
        public class Slacker : Worker
        {
            override public void DoWork()
            {
                Console.WriteLine("DoNoWork");
            }
        }
         */
        public static void ClassExamples3Func()
        {
            Worker w= new Worker();

            w.DoWork();
        }

        private static void Main(string[] args)
        {
            // Pipeline that dumps data to WorkPerformed1
            WorkPerformedHandler del1 = new WorkPerformedHandler(WorkPerformed1);

            WorkPerformedHandler del2 = new WorkPerformedHandler(WorkPerformed2);

            WorkPerformedHandler del3 = new WorkPerformedHandler(WorkPerformed2);

            del1(5, WorkType.Golf);
            del2(10, WorkType.GenerateReports);

            // Pass in deletage - del2 calls WorkPerformed2. It will invoke whatever was passed ie. WorkPerformed2
            DoWork(del2);

            // Adding handlers to Invocation list of Delegate1
            // Whenever del1 fires it will notify WorkPerformed2 and WorkPerformed3 as well
            del1 += del2;
            del1 += del3; // I could also do { del1 += del2 + del3 }

            // Events with Delegates
            // Attach handlers with delegates
            // Worker class 3 public events to wire up
            var worker = new Worker();

            // Without using Generic<T>
            worker.WorkPerformed += new WorkPerformedHandlerDelEvent(worker_WorkPerformed);

            // Wire event
            // specifying parameter signature match/pipeline
            worker.WorkPerfomedT += new EventHandler<WorkPerformedEventArgs>(worker_WorkPerformed);
            worker.WorkCompleted += worker_WorkCompleted; // Delegate Inference

            // Worker performs some task that exposes it's events. Whenever event is fired
            // subscribers (worker_WorkPerformed, worker_WorkCompleted) will be notified
            // Start work
            worker.DoWork(3, WorkType.GoToMeeting);

            // Testing class
            MyWorker w = new MyWorker();
            w.AttachListenerToMe += MyWorkerNotified;

            // Using Func with Events
            // Can't do this
            //w.AttachListenerToMe += Action<object, EventArgs> = (o, e) =>
            //    {
            //        Console.WriteLine();
            //    };

            string stringResult = w.DoWork();

            Console.Read();
        }