public void putWork(IWork work)
{
lock (_syncWorks)
{
_works.Add(work);
}
}
void closeDialog(NavigationContext context)
{
currentBackgroundTask = null;
var screenMgr = ServiceRegistration.Get<IScreenManager>();
if (screenMgr.TopmostDialogInstanceId == context.DialogInstanceId)
screenMgr.CloseTopmostDialog();
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkSucceededProcessingEventArgs"/> class.
/// </summary>
///
/// <param name="work">
/// The item of <see cref="IWork"/> that has been successfully processed.
/// </param>
///
/// <exception cref="ArgumentException">
/// If <paramref name="work"/> is null.
/// </exception>
public WorkSucceededProcessingEventArgs(IWork work)
{
if (work == null)
throw new ArgumentException("Argument: 'work' may not be null.");
this.Work = work;
}
private IWorkItem UpdateWorkItem(IWork work, string value, string[] options)
{
var items = value.Split(' ');
if (items.Length != 2)
{
return(null);
}
var actor = items[0].Trim();
var answer = items[1].Trim();
answer = options.FirstOrDefault(x => String.Compare(x, answer, StringComparison.OrdinalIgnoreCase) == 0);
if (answer == null)
{
return(null);
}
var wi = work.WorkItems.SingleOrDefault(x => String.Compare(x.Participant.Name, actor, StringComparison.OrdinalIgnoreCase) == 0);
if (wi == null)
{
return(null);
}
wi.Outcome = answer;
return(wi);
}
public static string ToJson(IWork work)
{
if (work == null)
throw new ArgumentNullException(nameof(work));
return JsonConvert.SerializeObject(work, Formatting.None, new JsonSerializerSettings() { TypeNameHandling = TypeNameHandling.All });
}
public ClientHelper(Random rand, ListBox logger, IWork work)
{
this.rand = rand;
this.logger = logger;
this.response = new StringBuilder(200);
this.work = work;
}
public static byte[] Serialize(IWork work)
{
if (work == null)
throw new ArgumentNullException(nameof(work));
return Encoding.UTF8.GetBytes(WorkSerializer.ToJson(work));
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.Organisation == null))
{
IErpOrganisation organisationCasted = item.As <IErpOrganisation>();
if ((organisationCasted != null))
{
this._parent.Organisation = organisationCasted;
return;
}
}
IWork worksCasted = item.As <IWork>();
if ((worksCasted != null))
{
this._parent.Works.Add(worksCasted);
}
if ((this._parent.ErpQuoteLineItem == null))
{
IErpQuoteLineItem erpQuoteLineItemCasted = item.As <IErpQuoteLineItem>();
if ((erpQuoteLineItemCasted != null))
{
this._parent.ErpQuoteLineItem = erpQuoteLineItemCasted;
return;
}
}
IProject projectsCasted = item.As <IProject>();
if ((projectsCasted != null))
{
this._parent.Projects.Add(projectsCasted);
}
}
/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
if ((this._parent.Organisation == item))
{
this._parent.Organisation = null;
return(true);
}
IWork workItem = item.As <IWork>();
if (((workItem != null) &&
this._parent.Works.Remove(workItem)))
{
return(true);
}
if ((this._parent.ErpQuoteLineItem == item))
{
this._parent.ErpQuoteLineItem = null;
return(true);
}
IProject projectItem = item.As <IProject>();
if (((projectItem != null) &&
this._parent.Projects.Remove(projectItem)))
{
return(true);
}
return(false);
}
public static int SendWork(this IEnumerable <Socket> sockets, IWork work)
{
using (var stream = new MemoryStream())
{
var lengthWriter = new BinaryWriter(stream);
lengthWriter.Write(0);
var formatter = new BinaryFormatter();
formatter.Serialize(stream, work);
lengthWriter.Seek(0, SeekOrigin.Begin);
lengthWriter.Write((int)(stream.Length - sizeof(int)));
var bytes = stream.ToArray();
var tasks = sockets.Select(socket => socket.SendAsync(bytes)).ToList();
try
{
Task.WaitAll(tasks.Cast <Task>().ToArray());
}
catch (Exception)
{
return(tasks.Count(e => e.IsCompleted));
}
return(tasks.Count());
}
}
private void DoWork(IWork work)
{
try
{
this.NotifyObservers(work, work.GetResult());
}
catch (Exception exception)
{
Exception e = exception;
switch (this.ExceptionHandling)
{
case ExceptionHandlingAction.DefaultBehaviour:
{
throw;
}
case ExceptionHandlingAction.CallEventHandler:
{
this.OnException(e);
break;
}
case ExceptionHandlingAction.CallEventHandlerAndLeakException:
{
this.OnException(e);
throw;
}
}
}
}
static void Main(string[] args)
{
//Interfacelerin kullanım şekilleri
CustomerManager customerManger = new CustomerManager();
//customerManger.Add(new SQLiteDal());
//customerManger.Delete(new OracleDal());
ICustomerDal[] customerDals = new ICustomerDal[]
{
new SQLiteDal(),
new OracleDal()
};
foreach (ICustomerDal customerDal in customerDals)
{
customerDal.Add();
customerDal.Delete();
customerDal.Update();
}
//Çoklu implementasyon örneği için MultiImplementation.cs bakınız...
//Devamı
IWork[] workersArray = new IWork[]
{
new Manager(),
new Worker(),
new Robot()
};
IEat[] eatArray = new IEat[]
{
new Manager(),
new Worker()
};
ISalary[] salaryArray = new ISalary[]
{
new Manager(),
new Worker()
};
foreach (IWork worker in workersArray)
{
worker.Work();
}
foreach (IEat eater in eatArray)
{
eater.Eat();
}
foreach (ISalary salaryGetter in salaryArray)
{
salaryGetter.Salary();
}
Console.Read();
}
/// <summary>
///
/// </summary>
/// <param name="work">work的创建和销毁由外界处理</param>
/// <param name="run"></param>
/// <returns></returns>
public void AddWork(IWork work, bool run = false)
{
if (work != null && !allWorks.Contains(work))
{
allWorks.Add(work);
if (run)
{
if (runningCount < runningWorks.Count)
{
runningWorks[runningCount++] = work;
}
else
{
runningWorks.Add(work);
runningCount++;
}
work.Start();
(work as ITick).Tick(0); //有些需要立即生效
if (work.IsFinished())
{
allWorks.Remove(work);
runningWorks.Remove(work);
runningCount--;
}
}
}
}
protected void SetUp()
{
Test test = new Test("Default", 0, 0, 0, 0, 0);
Configuration.Initialize(test);
_workorder = Substitute.For <IWork>();
_workorder.CurrentOpType.Returns(Op.OpTypes.DrillOpType1);
_workorder.CurrentOpSetupTime.Returns(0);
_workorder.CurrentOpEstTimeToComplete.Returns(1);
_workorder.Id.Returns(1);
ISchedulePlants ps = Substitute.For <ISchedulePlants>();
ps.ValidateWoForMachines(Arg.Any <int>(), Arg.Any <string>()).Returns(x => x[0]);
_plant = Substitute.For <IPlant>();
_plant.PlantScheduler.Returns(ps);
_bigData = Substitute.For <IHandleBigData>();
_bigData.IsBreakdown(Arg.Any <string>(), Arg.Any <DayTime>()).Returns(x => x[1]);
_bigData.IsNonConformance(Arg.Any <string>()).Returns(false);
_mes = Substitute.For <IMes>();
_dayTime = new DayTime();
_subject = new Workcenter("TestWC", Machine.Types.BigDrill);
_subject.SetMes(_mes);
_subject.AddPlant(_plant);
_subject.AddBigData(_bigData);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IWorkTask workTasksCasted = item.As <IWorkTask>();
if ((workTasksCasted != null))
{
this._parent.WorkTasks.Add(workTasksCasted);
}
if ((this._parent.Status == null))
{
IStatus statusCasted = item.As <IStatus>();
if ((statusCasted != null))
{
this._parent.Status = statusCasted;
return;
}
}
if ((this._parent.Work == null))
{
IWork workCasted = item.As <IWork>();
if ((workCasted != null))
{
this._parent.Work = workCasted;
return;
}
}
}
private static void AtWorkStation(IWork w)
{
Console.WriteLine("AtWorkStation");
Console.WriteLine();
w.StartWork();
w.StopWork();
}
public bool Add(IWork work, QueuePriority queuePriority)
{
if (!_run)
{
return(false);
}
if (_startInfo.DelayedInit)
{
_startInfo.DelayedInit = false;
Init();
}
if (work == null)
{
throw new ArgumentNullException("work", "cannot be null");
}
if (work.State != WorkState.INIT)
{
throw new InvalidOperationException(String.Format("WorkState must be {0}", WorkState.INIT));
}
if (!_run)
{
throw new InvalidOperationException("Threadpool is already (being) stopped");
}
work.State = WorkState.INQUEUE;
_workQueue.Add(work, queuePriority);
CheckThreadIncrementRequired();
return(true);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IProject projectsCasted = item.As <IProject>();
if ((projectsCasted != null))
{
this._parent.Projects.Add(projectsCasted);
}
IWorkCostDetail workCostDetailsCasted = item.As <IWorkCostDetail>();
if ((workCostDetailsCasted != null))
{
this._parent.WorkCostDetails.Add(workCostDetailsCasted);
}
IErpTimeEntry erpTimeEntriesCasted = item.As <IErpTimeEntry>();
if ((erpTimeEntriesCasted != null))
{
this._parent.ErpTimeEntries.Add(erpTimeEntriesCasted);
}
IWork worksCasted = item.As <IWork>();
if ((worksCasted != null))
{
this._parent.Works.Add(worksCasted);
}
}
public IWork Ship(int wo_id)
{
IWork wo = ShippingBuffer.Remove(wo_id);
_mes.Ship(wo_id);
return(wo);
}
public CategoriesController(ICategoryRepository repo, IMapper mapper, IBookRepository bookRepo, IWork work)
{
_repo = repo;
_mapper = mapper;
_bookRepo = bookRepo;
_work = work;
}
/// <summary>
/// Called by workers when the job queue is empty.
/// </summary>
internal void ReportInactive()
{
if (Interlocked.Decrement(ref activeThreads) <= 0)
{
IWork next = null;
currentJob?.TriggerComplete();
lock (workQueue) {
// Remove the old head, and check for a new one
int n = workQueue.Count;
if (n > 0)
{
workQueue.Dequeue();
}
if (n > 1)
{
next = workQueue.Peek();
}
else
{
// Avoid concurrent mod exception if another task starts up afterwards
foreach (var thread in threads)
{
thread.PrintExceptions();
}
}
currentJob = null;
}
if (next != null)
{
AdvanceNext(next);
}
}
}
private void GameMain_gameUpdateEvent(GameTime gameTime)
{
if (_works.Count > 0)
{
lock (_syncWorks)
{
TimeSpan totalDelta = TimeSpan.Zero;
int execWorkCount = 0;
int totalWorks = _works.Count;
for (int i = 0; i < _works.Count;)
{
var t1 = DateTime.Now;
IWork work = _works[i];
_works.RemoveAt(i);
work.run(gameTime);
var delta = DateTime.Now - t1;
totalDelta += delta;
if (totalDelta.TotalSeconds > 0.01f)
{
break;
}
execWorkCount++;
}
if (execWorkCount > 0)
{
// Console.WriteLine("execWork={0}/{1} totalDelta={2}", execWorkCount, totalWorks, totalDelta);
}
}
}
}
/// <summary> Create <see cref="ITaskWrapper{TArgument}" /> for given asyncWork </summary>
/// <param name="work"> Work instance </param>
/// <param name="attemptsCount"> Retry on fail attempts count </param>
/// <param name="cancellation"> Work cancellation token </param>
/// <returns> Wrapper and asyncWork completion task </returns>
public static (ITaskWrapper <object?> Work, Task Task) CreateWorkWrapper(IWork work, int attemptsCount = 1,
CancellationToken cancellation = default)
{
var wrapper = new WorkWrapper(work ?? throw new ArgumentNullException(nameof(work)), Math.Max(1, attemptsCount), cancellation);
return(wrapper, wrapper.WorkTask);
}
static void Main(string[] args)
{
IWork[] workers = new IWork[3]
{
new Manager(),
new Worker(),
new Robot()
};
foreach (var worker in workers)
{
worker.Work();
}
IEat[] eats = new IEat[2]
{
new Worker(),
new Manager()
};
foreach (var eat in eats)
{
eat.Eat();
}
}
public void Add(IWork workorder)
{
var wc = Workcenters.First(x => x.ReceivesType(workorder.CurrentOpType));
Mes.AddWorkorder(wc.Name, workorder);
wc.AddToQueue(workorder);
}
protected static void OnWorkOverwrite(object sender, WorkOverwriteEventArgs e)
{
IWork work = (sender as IWork);
if (GetDefaultOverwriteMode(work.ID) != OverwriteMode.Ask)
{
e.Overwrite = GetDefaultOverwriteMode(work.ID);
}
if (work.Aborted)
{
e.Overwrite = OverwriteMode.KeepOriginal;
}
if (!GetIsMuted((sender as IWork).ID))
{
if (WorkOverwrite != null)
{
WorkOverwrite(sender, e);
if (e.ApplyToAll)
{
SetDefaultOverwriteMode(work.ID, e.Overwrite);
}
}
}
}
public bool RemoveWork(IWork work)
{
foreach (string action in work.Action)
{
if (this.work.ContainsKey(action))
{
if (this.work[action].Count > 1)
{
foreach (string upon in work.Upon)
{
this.work[action].Remove(upon);
}
if (this.work[action].Count == 0)
{
this.work.Remove(action);
}
}
else
{
this.work.Remove(action);
}
return(true);
}
}
return(false);
}
public MainForm()
{
InitializeComponent();
this.rand = new Random();
this.work = new PrimeResolutionWork(this.rand);
this.helper = new ClientHelper(this.rand, this.lbEventDiary, this.work);
}
public IWork BootLoad()
{
if (state == ManagerState.INIT)
{
state = ManagerState.BOOT_LOADING;
var loaders = TempList <IWork> .Alloc();
var loader = DoLoad();
if (loader != null)
{
loaders.Add(loader);
}
foreach (var module in modules.Values)
{
var work = module.Load();
if (work != null)
{
loaders.Add(work);
}
}
if (loaders.Count > 0)
{
return(bootLoader = new ParallelWork("", loaders));
}
}
return(null);
}
/// <summary>
/// Executes the given work items potentially in parallel with each other.
/// This method will block until all work is completed.
/// </summary>
/// <param name="a">Work to execute.</param>
/// <param name="b">Work to execute.</param>
public void Do(IWork a, IWork b)
{
Task task = Start(b);
a.DoWork();
task.Wait();
}
protected virtual void worker_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
while (MainList.Count > 0)
{
IWork work = MainList.First.Value;
if (!work.Initialize())
{
work.OnFailed();
RunOnFailed();
return;
}
if (!work.Execute())
{
work.OnFailed();
RunOnFailed();
return;
}
work.OnCompleted();
MainList.RemoveFirst();
}
if (MainList.Count == 0)
{
RunOnCompleted();
}
}
/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
IProject projectItem = item.As <IProject>();
if (((projectItem != null) &&
this._parent.Projects.Remove(projectItem)))
{
return(true);
}
IWorkCostDetail workCostDetailItem = item.As <IWorkCostDetail>();
if (((workCostDetailItem != null) &&
this._parent.WorkCostDetails.Remove(workCostDetailItem)))
{
return(true);
}
IErpTimeEntry erpTimeEntryItem = item.As <IErpTimeEntry>();
if (((erpTimeEntryItem != null) &&
this._parent.ErpTimeEntries.Remove(erpTimeEntryItem)))
{
return(true);
}
IWork workItem = item.As <IWork>();
if (((workItem != null) &&
this._parent.Works.Remove(workItem)))
{
return(true);
}
return(false);
}
public void Dequeue_WhenHas1_ReturnsIt()
{
_subject.Enqueue(wo1);
IWork wo = _subject.Dequeue();
Assert.AreEqual(wo.Id, wo1.Id);
}
/// <summary>
/// Enqueues the task.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="skipIfAny">Skip task execution if any other task are queued</param>
private async void Post(IWork task)
{
if (disposed)
{
throw new InvalidOperationException("Worker is already disposed");
}
await semaphore.WaitAsync();
await Task.Run(() =>
{
try
{
lock (_locker)
{
_workQueue.Enqueue(task);
Monitor.PulseAll(_locker);
}
}
finally
{
semaphore.Release();
}
});
}
public IWork Work(DayTime dayTime, IHandleBigData bigData, string name)
{
if (CurrentWo == null)
{
if (Buffer.Count > 0)
{
CurrentWo = Buffer.Dequeue();
CurrentInspectionTime = _inspectionTime;
}
return(null);
}
IWork answer = null;
CurrentInspectionTime--;
if (CurrentInspectionTime == 0)
{
answer = CurrentWo;
CurrentWo = null;
answer.NonConformance = bigData.IsNonConformance(name);
if (!answer.NonConformance)
{
answer.SetNextOp();
}
}
return(answer);
}
public void Reset()
{
_work = null;
_timedout = false;
_signaled = false;
_waitHandle.Reset();
}
public NeedSomeOneToDoWork(IWork worker)
{
if (worker == null)
{
throw new ArgumentNullException(nameof(worker));
}
_worker = worker;
}
private void HandleEnded(IWork sender, WorkEventArgs e)
{
if (_workUnits.Any(w => !w.Equals(sender) && !w.HasEnded))
{
return;
}
EndTransaction(_workUnits.All(w => w.IsComplete));
}
public Work(WorkType type, IWork parent, IArtist artist, string name, short year, uint number)
{
this.type = type;
this.parent = parent;
this.artist = artist;
this.name = name ?? string.Empty;
this.year = year;
this.number = number;
}
public void AddWork(IWork work)
{
if (work == null)
throw new ArgumentNullException("work");
if (works.Contains(work))
return;
works.Add(work);
}
public void EndWorking()
{
var currentProgressService = CurrentWork;
currentProgressService.EndWork();
_lastWork = _worksStack.Pop();
if (!_worksStack.Any())
IsWorrking = false;
}
public void RemoveWork(IWork work)
{
if (work == null)
throw new ArgumentNullException("work");
if (!works.Contains(work))
return;
works.Remove(work);
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkFailedProcessingEventArgs"/> class.
/// </summary>
///
/// <param name="work">
/// The item of <see cref="IWork"/> that has failed.
/// </param>
///
/// <param name="message">
/// A message that indicates what has failed.
/// </param>
///
/// <exception cref="ArgumentException">
/// If <paramref name="work"/> is null.
/// </exception>
///
/// <exception cref="ArgumentException">
/// If <paramref name="message"/> is null, blank or whitespace.
/// </exception>
public WorkFailedProcessingEventArgs(IWork work, string message)
{
if (work == null)
throw new ArgumentException("Argument: 'work' may not be null.");
if (string.IsNullOrWhiteSpace(message))
throw new ArgumentException("Argument: 'message' may not be null, blank or whitespace.");
this.Message = message;
this.Work = work;
}
/// <summary>
/// Registers/Adds work to the <see cref="CrawlerWorkSource"/>.
/// </summary>
/// <param name="work"><see cref="ICrawlerWork"/></param>
public void RegisterWork(IWork work)
{
if (work.IsReadyToStart())
{
availableWork.Enqueue(work);
}
else
{
workSourceScheduler.ScheduleWork(work);
}
}
public void Log(IWork work, logType type, string message)
{
lock (_logList)
{
if (_lastLog.Type != type || _lastLog.Message != message)
_logList.Add(_lastLog = new logLine(type, message));
if (!String.IsNullOrEmpty(_fileName) && (type == logType.error || type == logType.success))
using (StreamWriter sw = new StreamWriter(File.OpenWrite(_fileName)))
foreach (var line in _logList)
sw.WriteLine(String.Format("[{0}] {1} - {2}", line.Time, line.Type.ToString(), line.Message));
}
}
public void Publish(IWork work, string routingKey = null, IBasicProperties properties = null)
{
if (work == null)
throw new ArgumentNullException(nameof(work));
if (string.IsNullOrWhiteSpace(routingKey))
throw new ArgumentNullException(nameof(routingKey));
if (properties == null)
{
properties = this.Channel.CreateBasicProperties();
//properties.AppId = string.Empty;
//properties.ClusterId = string.Empty;
//properties.ContentEncoding = string.Empty;
//properties.ContentType = "application/json"; // Set by the Message Serializer
//properties.CorrelationId = string.Empty;
properties.DeliveryMode = Constants.Persistent;
//properties.Expiration = string.Empty;
//properties.MessageId = string.Empty;
//properties.Priority = 0;
//properties.ReplyTo = string.Empty;
//properties.Type = msg.GetType().Name; // Set by the Message Serializer, use this field to store the type of object encoded in the Body. Allows for a factory deserializer to easily determine what to return
//properties.UserId = string.Empty;
}
if (!this.Channel.IsOpen)
throw new InvalidOperationException("Channel is not open");
var bytes = WorkSerializer.Serialize(work);
properties.ContentEncoding = WorkSerializer.ContentEncoding;
properties.ContentType = WorkSerializer.ContentType;
properties.Type = work.GetType().FullName;
var WorkExchange = Constants.WorkExchangeSettings;
this.Channel.ExchangeDeclare(WorkExchange.Name, WorkExchange.ExchangeType, WorkExchange.Durable, WorkExchange.AutoDelete, WorkExchange.Arguments);
this.Channel.BasicPublish(WorkExchange.Name, routingKey, properties, bytes);
}
public void Add(IWork work, QueuePriority priority)
{
lock (_queueMutex)
{
bool mustQueue = true;
while (_workWaiters.Count > 0)
{
WorkWaiter waiter = _workWaiters[0];
_workWaiters.Remove(waiter);
if (waiter.Signal(work))
{
mustQueue = false;
break;
}
}
if (mustQueue)
{
Queue<IWork> queue = GetQueue(priority);
queue.Enqueue(work);
_queueItemCount++;
}
}
}
/// <summary>
/// Enqueues the specified work.
/// </summary>
/// <param name="work">The work.</param>
/// <returns><value>true</value> if the work was enqueued, else <value>false</value>.</returns>
/// <exception cref="ArgumentException">
/// If <paramref name="work"/> is null.
/// </exception>
public void Enqueue(IWork work)
{
if (work == null)
throw new ArgumentException("Argument: 'work' must not be null.");
lock (this.queueLocker)
{
this.queue.Enqueue(work);
Monitor.Pulse(this.queueLocker);
}
}
private void WorkItemHandler(IBasicProperties props, IWork iWork)
{
var work = iWork as SampleWorkItem;
if (work == null)
throw new Exception($"Don't know how to work on '{iWork.GetType().FullName}' items");
this.InternalState = InternalStateEnum.Busy;
var currentStatus = new ServiceComponentStatus() { Process = this.Process, ServiceComponent = this.GetType().Name, Status = "Working", SubStatus = "Starting" };
this.PublishEvent(currentStatus);
var workItemType = work.ItemType;
var workItemId = work.ItemId;
var workDelay = work.WorkDelay;
currentStatus.SubStatus = "Executing";
this.PublishEvent(currentStatus);
Thread.Sleep(workDelay);
currentStatus.SubStatus = "Completing";
this.PublishEvent(currentStatus);
this.InternalState = InternalStateEnum.Idle;
this.PublishEvent("Idle");
}
public WorkerThread(IWork work, string name) : this(new ThreadStart(work.Start), name)
{
}
public void Reset()
{
_work = null;
_timedout = false;
_signaled = false;
_waitHandle.Reset();
}
public bool Add(IWork work)
{
return Add(work, QueuePriority.Normal);
}
public bool Add(IWork work, QueuePriority queuePriority)
{
if (!_run)
return false;
if (_startInfo.DelayedInit)
{
_startInfo.DelayedInit = false;
Init();
}
if (work == null)
throw new ArgumentNullException("work", "cannot be null");
if (work.State != WorkState.INIT)
throw new InvalidOperationException(String.Format("WorkState must be {0}", WorkState.INIT));
if (!_run)
throw new InvalidOperationException("Threadpool is already (being) stopped");
work.State = WorkState.INQUEUE;
_workQueue.Add(work, queuePriority);
CheckThreadIncrementRequired();
return true;
}
/// <summary>
/// Adds work to the pool's <see cref="CrawlerWorkSource"/>
/// </summary>
/// <param name="job"></param>
public void AddWork(IWork job)
{
workSource.RegisterWork(job);
jobsInSource++;
}
public void Add(IWork work)
{
Add(work, QueuePriority.Normal);
}
private void HandleFailedWork(IWork workToBeProcessed, string message)
{
lock (this.queueLocker)
{
this.failed.Add(workToBeProcessed);
var args = new WorkFailedProcessingEventArgs(workToBeProcessed, message);
this.OnWorkFailed(args);
}
}
private void SaveWork(IBatch<IWork> batch, IWork work)
{
batch.Save(work);
foreach (var child in work.Children)
{
SaveWork(batch, child);
}
}
public bool Signal(IWork work)
{
lock (this)
{
if (!_timedout)
{
_work = work;
_signaled = true;
_waitHandle.Set();
return true;
}
}
return false;
}
public void ScheduleWork(IWork work)
{
unmanagedPendingWork.Enqueue(work);
WakeUpTheManager();
}
/// <summary>
/// Schedule saving of all settings in the near future
/// </summary>
public static void Save()
{
IThreadPool tp = GlobalServiceProvider.Get<IThreadPool>();
if (_delaySave == null)
{
_delaySave = tp.Add(LazySave, "Wait for saving SkinSettings");
}
else if (_delaySave.State != WorkState.INPROGRESS && _delaySave.State != WorkState.INQUEUE)
{
_delaySave = tp.Add(LazySave,"Wait for saving SkinSettings");
}
}
