void OnInstanceDeleted(AwaitableEvent <GlobalDeleteEventArgs> ev)
{
Logger.Debug("Instance saved. Initiating publish checks.");
var type = ev.Args.EntityType;
var instance = ev.Args.Entity;
if (!DependenciesEnitityTypes.Contains(type))
{
Logger.Debug("Publish aborted: " + type.Name + " is not of type " + DomainType.Name);
return;
}
ev.Do(async() =>
{
if (type == typeof(TDomain))
{
await Publish(instance as TDomain, toDelete: true);
}
else
{
await
(await FindRelationsOf(instance))
.ExceptNull()
.Do(async p => await Publish(p));
}
});
}
void OnInstanceSaved(AwaitableEvent <GlobalSaveEventArgs> ev)
{
var item = ev.Args.Entity;
Logger.Debug("Instance saved. Initiating publish checks.");
if (!DependenciesEnitityTypes.Contains(item.GetType()))
{
Logger.Debug("Publish aborted: " + item.GetType().Name + " is not of type " + DomainType.Name);
return;
}
ev.Do(async() =>
{
if (item is TDomain entity)
{
await Publish(entity);
}
else if (item != null)
{
await
(await FindRelationsOf(item))
.ExceptNull()
.Do(async p => await Publish(p));
}
});
}
/// <summary>
/// Enqueues a n-dimensional kernel to the command queue, which is executed asynchronously.
/// </summary>
/// <param name="kernel">The kernel that is to be enqueued.</param>
/// <param name="workDimension">The dimensionality of the work.</param>
/// <param name="workUnitsPerKernel">The number of work units per kernel.</param>
/// <exception cref="OpenClException">
/// If the kernel could not be enqueued, then an <see cref="OpenClException" /> is
/// thrown.
/// </exception>
public Task EnqueueNDRangeKernelAsync(Kernel kernel, int workDimension, int workUnitsPerKernel)
{
// Creates a new task completion source, which is used to signal when the command has completed
TaskCompletionSource <bool> taskCompletionSource = new TaskCompletionSource <bool>();
// Enqueues the kernel
Result result = EnqueuedCommandsNativeApi.EnqueueNDRangeKernel(
Handle,
kernel.Handle,
( uint )workDimension,
null,
new[] { new IntPtr(workUnitsPerKernel) },
null,
0,
null,
out IntPtr waitEventPointer
);
// Checks if the kernel was enqueued successfully, if not, then an exception is thrown
if (result != Result.Success)
{
throw new OpenClException("The kernel could not be enqueued.", result);
}
// Subscribes to the completed event of the wait event that was returned, when the command finishes, the task completion source is resolved
AwaitableEvent awaitableEvent = new AwaitableEvent(waitEventPointer);
awaitableEvent.OnCompleted += (sender, e) =>
{
try
{
if (awaitableEvent.CommandExecutionStatus ==
CommandExecutionStatus.Error)
{
taskCompletionSource.TrySetException(
new OpenClException(
$"The command completed with the error code {awaitableEvent.CommandExecutionStatusCode}."
)
);
}
else
{
taskCompletionSource.TrySetResult(true);
}
}
catch (Exception exception)
{
taskCompletionSource.TrySetException(exception);
}
finally
{
awaitableEvent.Dispose();
}
};
return(taskCompletionSource.Task);
}
private async void TicTacToe()
{
Debugger.Break();
var pointerPressed = new AwaitableEvent <PointerRoutedEventArgs>();
m_grid.PointerPressed += pointerPressed.Handler;
while (true)
{
// Initialize: Clear board, Turn = X
ClearBoard();
Char turn = 'X';
// Loop until there is a winner (3 in a row)
for (Boolean winner = false; !winner;)
{
// Wait for PointerPressed event
AwaitableEventArgs <PointerRoutedEventArgs> eventArgs = await pointerPressed.RaisedAsync();
// If square empty, put symbol in square
Point position = eventArgs.Args.GetCurrentPoint(m_grid).Position;
var textblock = m_grid.GetAt(
(Int32)(position.Y / (m_grid.ActualHeight / 3)),
(Int32)(position.X / (m_grid.ActualWidth / 3)));
if (textblock.Text[0] != c_emptySquare[0])
{
continue;
}
textblock.Text = turn.ToString();
// If not 3 in a row
if (!(winner = Winner(turn)))
{
// If a tie: Show tie dialog, re-initialize
if (Tie())
{
await new MessageDialog("Tie game").ShowAsync(); break;
}
// Switch turn (X -> O or O -> X)
turn = (turn == 'X') ? 'O' : 'X';
}
else
{
// If 3 in a row: Show winner dialog, re-initialize
await new MessageDialog(turn + " wins!").ShowAsync();
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IxInstance"/> class.
/// </summary>
/// <remarks>
/// Instance creates in the "Half-instantiated state".
/// </remarks>
/// <param name="providerNode">Node that produces instance.</param>
/// <param name="parentInstance">Direct parent instance.</param>
/// <param name="creatorTempLock">First temp lock for the creator of a new instance.</param>
public IxInstance(
IxProviderNode providerNode,
[CanBeNull] IIxInstance parentInstance,
out IIxInstanceLock creatorTempLock)
: base(providerNode.Host.InstanceTreeSyncRoot)
{
ProviderNode = providerNode;
_parentInstance = parentInstance;
_ownedLocks = new ProcessableSet <IIxInstanceLock>();
_locks = new ProcessableSet <IIxInstanceLock>();
_childrenDisposeCompleted = new AwaitableEvent();
if (parentInstance != null)
{
new IxInstanceChildLock(parentInstance, this);
}
creatorTempLock = new IxInstancePinLock(this);
_initTempLock = creatorTempLock;
}
public async Task AwaitableEventTest()
{
// Simple async test.
using (var ev = new AwaitableEvent())
{
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
Task.Factory.StartNew(
async() =>
{
await Task.Delay(50);
// ReSharper disable once AccessToDisposedClosure
ev.Set();
});
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
await ev;
ev.IsSet.Should().BeTrue();
}
}
/// <summary>
/// Reads the specified memory object associated with this command queue asynchronously.
/// </summary>
/// <param name="memoryObject">The memory object that is to be read.</param>
/// <param name="outputSize">The number of array elements that are to be returned.</param>
/// <typeparam name="T">The type of the array that is to be returned.</typeparam>
/// <returns>Returns the value of the memory object.</param>
public Task <T[]> EnqueueReadBufferAsync <T>(MemoryObject memoryObject, int outputSize) where T : struct
{
// Creates a new task completion source, which is used to signal when the command has completed
TaskCompletionSource <T[]> taskCompletionSource = new TaskCompletionSource <T[]>();
// Allocates enough memory for the result value
IntPtr resultValuePointer = IntPtr.Zero;
int size = Marshal.SizeOf <T>() * outputSize;
resultValuePointer = Marshal.AllocHGlobal(size);
// Reads the memory object, by enqueuing the read operation to the command queue
IntPtr waitEventPointer;
Result result = EnqueuedCommandsNativeApi.EnqueueReadBuffer(Handle, memoryObject.Handle, 1, UIntPtr.Zero,
new UIntPtr((uint)size), resultValuePointer, 0, null, out waitEventPointer);
// Checks if the read operation was queued successfuly, if not, an exception is thrown
if (result != Result.Success)
{
throw new OpenClException("The memory object could not be read.", result);
}
// Subscribes to the completed event of the wait event that was returned, when the command finishes, the task completion source is resolved
AwaitableEvent awaitableEvent = new AwaitableEvent(waitEventPointer);
awaitableEvent.OnCompleted += (sender, e) =>
{
try
{
// Checks if the command was executed successfully, if not, then an exception is thrown
if (awaitableEvent.CommandExecutionStatus == CommandExecutionStatus.Error)
{
taskCompletionSource.TrySetException(new OpenClException(
$"The command completed with the error code {awaitableEvent.CommandExecutionStatusCode}."));
return;
}
// Goes through the result and converts the content of the result to an array
T[] resultValue = new T[outputSize];
for (int i = 0; i < outputSize; i++)
{
resultValue[i] =
Marshal.PtrToStructure <T>(IntPtr.Add(resultValuePointer, i * Marshal.SizeOf <T>()));
}
// Sets the result
taskCompletionSource.TrySetResult(resultValue);
}
catch (Exception exception)
{
taskCompletionSource.TrySetException(exception);
}
finally
{
// Finally the allocated memory has to be freed and the allocated resources are disposed of
if (resultValuePointer != IntPtr.Zero)
{
Marshal.FreeHGlobal(resultValuePointer);
}
awaitableEvent.Dispose();
}
};
// Returns the task completion source, which resolves when the command has finished
return(taskCompletionSource.Task);
}
