protected override void DoProcess(ProcessItemHandler handler)
 {
     if (!this.UsePipes)
     {
         this.ProcessExtract(handler);
     }
     else
     {
         WaitHandle[] waitHandles = new WaitHandle[] { this.FinishedEvent, this.BeforeExtractItem };
         ThreadPool.QueueUserWorkItem(new WaitCallback(this.ProcessExtract));
         AsyncProcessWcxItemEventArgs e = new AsyncProcessWcxItemEventArgs(this);
         while (true)
         {
             if (WaitHandle.WaitAny(waitHandles) == 0)
             {
                 break;
             }
             this.ExtractNeeded = false;
             handler(e);
             if (e.Cancel)
             {
                 this.TerminateEvent.Set();
             }
             else if (!this.ExtractNeeded)
             {
                 this.ConfirmExtractItem.Set();
             }
         }
     }
     if (this.ProcessResult != 0)
     {
         WcxErrors.ThrowExceptionForError(this.ProcessResult);
     }
 }
Пример #2
0
        /// <summary>
        /// Synchronous processing
        /// </summary>
        public static void Example1()
        {
            var          ps = PowerShell.Create().AddCommand("Get-Process");
            IAsyncResult pipeAsyncResult = ps.BeginInvoke();

            foreach (PSObject result in ps.EndInvoke(pipeAsyncResult))
            {
                ProcessItemHandler?.Invoke(new ProcessItem()
                {
                    Value = $"{result.Members["ProcessName"].Value,-20}{result.Members["Id"].Value}"
                });
            }
        }
Пример #3
0
        /// <summary>
        /// Asynchronous processing
        /// </summary>
        /// <returns></returns>
        public static async Task Example2Task()
        {
            await Task.Run(async() =>
            {
                await Task.Delay(0);
                var ps = PowerShell.Create().AddCommand("Get-Process");

                var pipeAsyncResult = ps.BeginInvoke();

                foreach (var result in ps.EndInvoke(pipeAsyncResult))
                {
                    ProcessItemHandler?.Invoke(new ProcessItem()
                    {
                        Value = $"{result.Members["ProcessName"].Value,-20}{result.Members["Id"].Value}"
                    });
                }
            });
        }
        public void Process(ProcessItemHandler handler)
        {
            switch (this.State)
            {
                case ProcessorState.InProcess:
                    throw new InvalidOperationException("Processor already in process");

                case ProcessorState.Finished:
                    throw new InvalidOperationException("Cannot start one processor twice");
            }
            this.FState = ProcessorState.InProcess;
            try
            {
                this.DoProcess(handler);
            }
            finally
            {
                this.FState = ProcessorState.Finished;
            }
        }
Пример #5
0
        /// <summary>
        /// Creates a processing queue
        /// </summary>
        /// <param name="threads">number of threads to fire delegates on to process items</param>
        /// <param name="itemHandler">delegate to call</param>
        /// <param name="name">name to assign to the threads</param>
        /// <param name="supportInjection">Whether or not the queue should be created to support injection onto a high priority list which gets processed ahead of the main list</param>
        public BackgroundProcessor(int threads, ProcessItemHandler itemHandler, string name)
        {
            if (threads <= 0)
            {
                throw new ArgumentException("threads cannot be <= zero", "threads");
            }
            if (itemHandler == null)
            {
                throw new ArgumentNullException("itemHandler");
            }

            this.handler = itemHandler;
            for (int i = 0; i < threads; ++i)
            {
                Thread t = new Thread(new ThreadStart(WorkerThread));
                t.Name         = name + "-Worker";
                t.IsBackground = true;
                t.Priority     = ThreadPriority.Lowest;
                t.Start();
            }
        }
 protected override void DoProcess(ProcessItemHandler handler)
 {
     if (!base.Context.FormatInfo.CanDeleteFiles)
     {
         throw new NotSupportedException();
     }
     List<string> files = new List<string>(base.Items.Values.Count);
     foreach (WcxArchiveItem item in base.Items.Values)
     {
         files.Add(item.Name);
         if (handler != null)
         {
             handler(new SimpleProcessItemEventArgs(item, base.GetUserState(item)));
         }
     }
     int errorCode = base.Context.FormatInfo.DeleteFiles(base.Context.ArchiveName, files);
     if (errorCode != 0)
     {
         WcxErrors.ThrowExceptionForError(errorCode);
     }
     LocalFileSystemCreator.RaiseFileChangedEvent(WatcherChangeTypes.Changed, base.Context.ArchiveName);
 }
 protected abstract void DoProcess(ProcessItemHandler handler);