private void ProcessIStackItem(IStackItem item, bool silenceEvents = false)
{
if (!item.IsProcessed)
{
item.Process();
item.IsProcessed = true;
if (!silenceEvents)
{
ItemProcessed?.BeginInvoke(this, item, null, null);
}
}
}
public BaseFlowBlock(int capacity = 1000, BlockType procType = BlockType.Transform,
int threadCount = 4)
{
_id = __id;
Interlocked.Increment(ref __id);
_linkedBlockCompletions = new List <Task>();
ProcType = procType;
_onCompletionTasks = new List <Task>();
var options = new DataflowBlockOptions()
{
BoundedCapacity = capacity
};
_buffer = new BufferBlock <TIn>(options);
var ops = new DataflowLinkOptions {
PropagateCompletion = true
};
var executionBlockOptions = new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = threadCount,
BoundedCapacity = capacity
};
switch (procType)
{
case BlockType.Action:
_actionBlock = new ActionBlock <TIn>((item) =>
{
var receivedResult = OnBlockReceived(item);
//So that we can actually make a link
ItemProcessed?.Invoke(receivedResult);
}, executionBlockOptions);
_buffer.LinkTo(_actionBlock, ops);
break;
case BlockType.Transform:
_transformer = new TransformBlock <TIn, TOut>(
new Func <TIn, TOut>(OnBlockReceived), executionBlockOptions);
_transformLinkInstance = _buffer.LinkTo(_transformer, ops);
break;
default:
throw new Exception("Not supported");
}
}
public EventExamples()
{
OrderProcessed?.Invoke(null, EventArgs.Empty);
ItemRequested?.Invoke(null, new VendingRequestArgs(1));
ItemProcessed?.Invoke(null, new VendingRequestArgs(99));
}
private Tuple <bool, string> RecursiveRenamer(DirectoryInfo directory)
{
try
{
if (abortSearch)
{
return(abortReturn);
}
foreach (var currentFile in directory.GetFiles())
{
if (abortSearch)
{
return(abortReturn);
}
if (renameProcessor.IsMatch(currentFile.Name, ItemType.File))
{
var oldName = currentFile.Name;
var newName = renameProcessor.RefactoredName(currentFile.Name, ItemType.File);
while (File.Exists(currentFile.DirectoryName + "\\" + newName))
{
newName = Path.GetFileNameWithoutExtension(newName) + "_2" + Path.GetExtension(newName);
}
currentFile.MoveTo(currentFile.DirectoryName + "\\" + newName);
AddFileToLastChanges(currentFile.DirectoryName + "\\" + oldName,
currentFile.DirectoryName + "\\" + newName);
ItemProcessed?.Invoke(directory.FullName, oldName, newName);
}
else
{
ItemProcessed?.Invoke(directory.FullName, currentFile.Name, "Name nicht geändert");
}
}
if (includeSubfolders)
{
if (abortSearch)
{
return(abortReturn);
}
foreach (var currentDirectory in directory.GetDirectories())
{
var retVal = RecursiveRenamer(currentDirectory);
if (!retVal.Item1)
{
return(retVal);
}
}
}
if (abortSearch)
{
return(abortReturn);
}
if (changeFolderNames)
{
if (renameProcessor.IsMatch(directory.Name, ItemType.Directory))
{
var oldName = directory.Name;
var newName = renameProcessor.RefactoredName(directory.Name, ItemType.Directory);
if (directory.Parent != null)
{
var fullOldName = directory.Parent.FullName + "\\" + oldName;
var fullNewName = directory.Parent.FullName + "\\" + newName;
while (Directory.Exists(fullNewName))
{
fullNewName += "_2";
}
directory.MoveTo(fullNewName);
AddDirectoryToLastChanges(fullOldName, fullNewName);
}
ItemProcessed?.Invoke(directory.FullName + "\t [Ordnername geändert]", oldName, newName);
}
}
}
catch (Exception except)
{
return(new Tuple <bool, string>(false, except.Message));
}
return(new Tuple <bool, string>(true, String.Empty));
}
protected virtual void OnItemFinished(T item)
{
ItemProcessed?.Invoke(item);
}
private void OnItemProcessed(T item)
{
ItemProcessed?.Invoke(item);
}
private void OnItemProcessed()
{
ItemProcessed?.Invoke(this, new EventArgs());
}
public void ItemProcessedEvent(LogEntry logEntry, int count, int total)
{
ItemProcessed?.Invoke(null, new MigrationItemEventArgs {
LogEntry = logEntry, Count = count, Total = total
});
}
