public PointersEvents()
{
_logPointerPressed = new PointerEventHandler((snd, e) =>
{
CreateHandler(PointerPressedEvent, "Pressed", _ptPressedHandle)(snd, e);
if (_ptPressedCapture.IsChecked ?? false)
{
((UIElement)snd).CapturePointer(e.Pointer);
}
});
this.InitializeComponent();
_logPointerEntered = new PointerEventHandler(CreateHandler(PointerEnteredEvent, "Entered", _ptEnteredHandle));
_logPointerMoved = new PointerEventHandler(CreateHandler(PointerMovedEvent, "Moved", _ptMovedHandle));
_logPointerReleased = new PointerEventHandler(CreateHandler(PointerReleasedEvent, "Released", _ptReleasedHandle));
_logPointerExited = new PointerEventHandler(CreateHandler(PointerExitedEvent, "Exited", _ptExitedHandle));
_logPointerCanceled = new PointerEventHandler(CreateHandler(PointerCanceledEvent, "Canceled", _ptCanceledHandle));
_logPointerCaptureLost = new PointerEventHandler(CreateHandler(PointerCaptureLostEvent, "CaptureLost", _ptCaptureLostHandle));
_logManipulationStarting = new ManipulationStartingEventHandler(CreateHandler(ManipulationStartingEvent, "Manip starting", _manipStartingHandle));
_logManipulationStarted = new ManipulationStartedEventHandler(CreateHandler(ManipulationStartedEvent, "Manip started", _manipStartedHandle));
_logManipulationDelta = new ManipulationDeltaEventHandler(CreateHandler(ManipulationDeltaEvent, "Manip delta", _manipDeltaHandle));
_logManipulationCompleted = new ManipulationCompletedEventHandler(CreateHandler(ManipulationCompletedEvent, "Manip completed", _manipCompletedHandle));
_logTapped = new TappedEventHandler(CreateHandler(TappedEvent, "Tapped", _gestureTappedHandle));
_logDoubleTapped = new DoubleTappedEventHandler(CreateHandler(DoubleTappedEvent, "DoubleTapped", _gestureDoubleTappedHandle));
_log.ItemsSource = _eventLog;
_pointerType.ItemsSource = Enum.GetNames(typeof(PointerDeviceType));
_pointerType.SelectedValue = PointerDeviceType.Touch.ToString();
_manipMode.ItemsSource = _manipulationModes.Keys;
_manipMode.SelectedValue = _manipulationModes.First().Key;
_isReady = true;
OnConfigChanged(null, null);
}
protected async override Task RunAsync(Execution <HandleContext> execution)
{
try
{
using (IHandlerInstance handler = await CreateHandler.RunAsync(execution.Context).ConfigureAwait(false))
{
var handleContext = new HandlerContext(execution.Context.Message.Payload, handler.Current, execution.Context.Message);
await BeginHandle.RunAsync(handleContext).ConfigureAwait(false);
await ActualHandle.RunAsync(handleContext).ConfigureAwait(false);
await EndHandle.RunAsync(handleContext).ConfigureAwait(false);
}
}
catch (Exception ex)
{
var context = new ErrorContext(ex, execution.Context.Message, execution.Context.HandlerType);
context.AssignPropertySafely <IWorkflowContextWithServiceProvider>(prop => prop.ServiceProvider = execution.Context.ServiceProvider);
await Error.RunAsync(context).ConfigureAwait(false);
throw;
}
finally
{
await Finalize.RunAsync(execution.Context).ConfigureAwait(false);
}
}
public ISerializableObject CreateISerializableObject(Type type)
{
AttributeWorker w = AttributeWorker.GetInstance(Target);
ISerializableObject iso = null;
try
{
iso = (ISerializableObject)Activator.CreateInstance(type);
}
catch (InvalidCastException)
{
throw new SerializerException();
}
_objectPool.Register(iso);
ResolverData <ISerializableObject> data = new ResolverData <ISerializableObject>();
data.FieldsToResolve = AttributeWorker.RetrieveAllFields(iso.GetType());
data.HandledItem = iso;
CreateHandler handler = new CreateHandler(this);
RelationResolver <ISerializableObject> resolver = new RelationResolver <ISerializableObject>();
resolver.Handler = handler;
resolver.StartRelationResolving(data);
return(iso);
}
public BaseRecycler(CreateHandler createHandler, CheckValidHandler checkValidHandler, ResetHandler resetHandler, DestroyHandler destroyHandler)
{
items = new QueuedList <T>();
OnCreateHandler = createHandler;
OnCheckValidHandler = checkValidHandler;
OnResetHandler = resetHandler;
OnDestroyHandler = destroyHandler;
}
public LoopingEventHubReceiverConnection(
ITestablePartitionReceiver receiver,
CreateHandler handlers,
IEnumerable <Unit> loop)
{
_receiver = receiver;
_handlers = handlers;
_loop = loop;
}
public Recycler(CreateHandler instantiator)
{
if (instantiator == null)
{
throw new ArgumentNullException(nameof(instantiator));
}
this.instantiator = instantiator;
}
public void sync_handlers_should_run_in_reverse_order()
{
List <object> results = new List <object>();
foreach (char id in new object[] { 'A', 'B', 'C', 'D' })
{
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { id }));
}
dispatcher.DispatchMessage(message, true);
Assert.That(results, Is.EqualTo(new object[] { 'D', 'C', 'B', 'A' }).AsCollection);
}
public void terminated_message_should_not_reach_further_handlers_when_reversed()
{
List <object> results = new List <object> ();
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'A' }));
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'B' }));
dispatcher.AddMessageHandler(message, CreateHandler.HandlerThatErrors((Action <object>)results.Add, new object[] { "C (with error)" }));
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'D' }));
dispatcher.DispatchMessage(message, true);
Assert.That(results, Is.EqualTo(new object[] { 'D', "C (with error)" }).AsCollection);
}
public DBAccess()
{
connection.DataSource = @"MSI"; //the data source of the connection
connection.InitialCatalog = @"SENGroup25DB"; //the inital catalog of the connection
connection.IntegratedSecurity = true; //the integrated security of the connection
createDataHandler = new CreateHandler(connection.ToString());
deleteDataHandler = new DeleteHandler(connection.ToString());
readDataHandler = new ReadHandler(connection.ToString());
updateDataHandler = new UpdateHandler(connection.ToString());
}
public SqlPersistenceProviderFactory(string connectionString, bool serializeAsText, TimeSpan lockTimeout)
{
this.ConnectionString = connectionString;
this.LockTimeout = lockTimeout;
this.SerializeAsText = serializeAsText;
this.loadHandler = new LoadHandler(this);
this.createHandler = new CreateHandler(this);
this.updateHandler = new UpdateHandler(this);
this.unlockHandler = new UnlockHandler(this);
this.deleteHandler = new DeleteHandler(this);
}
public async Task callback_is_called_once_after_async_handler()
{
int callbackCount = 0;
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler());
dispatcher.DispatchMessage(message, delegate() {
callbackCount++;
});
await Delay();
Assert.That(callbackCount, Is.EqualTo(1));
}
public ApiResponse <string> Post([FromServices] CreateHandler handler, Create request)
{
int result = handler.Handle(request);
return(new ApiResponse <string>()
{
Success = true,
Message = "آدرس با موفقیت ایجاد شد"
,
Data = string.Concat(this.Request.Scheme, "://", this.Request.Host, "/api/url/", result)
});
}
public async Task terminated_async_message_should_not_reach_further_handlers()
{
List <object> results = new List <object> ();
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'A' }));
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'B' }));
dispatcher.AddMessageHandler(message, CreateHandler.HandlerThatErrors((Action <object>)results.Add, new object[] { "C (with error)" }));
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'D' }));
dispatcher.DispatchMessage(message);
await Delay(200);
Assert.That(results, Is.EqualTo(new object[] { 'A', 'B', "C (with error)" }).AsCollection);
}
public async Task HandleFunctionTest()
{
Create create =
new Create()
{
Text = "test", Title = "title", ValidTo = DateTime.Now.AddDays(1)
};
CreateHandler handler = new CreateHandler(this.unitOfWork, this.todoRepository);
var result = await handler.Handle(create);
Assert.Equal(ApplicationServiceStatus.Ok, result.Status);
Assert.Equal(1, result.Data);
}
public async Task async_and_sync_handlers_should_run_in_order_when_reversed()
{
List <object> results = new List <object> ();
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'A' }));
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'B' }));
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'C' }));
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'D' }));
dispatcher.DispatchMessage(message, true);
await Delay(200);
Assert.That(results, Is.EqualTo(new object[] { 'D', 'C', 'B', 'A' }).AsCollection);
}
public async Task Handle(Create command, CreateHandler subject)
{
// Arrange
// Act
var result = await subject.Handle(command, default);
// Assert
result
.Should()
.NotBeNull().And
.BeOfType <Conteudo>().And
.BeEquivalentTo(result);
}
public void handlers_handle_object()
{
List <object> expected = new List <object> {
"handler1", "handler2", "handler3"
};
List <object> actual = new List <object> ();
objectProcessor.AddObjectHandler(new InstanceOfMatcher(typeof(String)), CreateHandler.Handler <object>((Action <object>)actual.Add, new object[] { "handler1" }));
objectProcessor.AddObjectHandler(new InstanceOfMatcher(typeof(String)), CreateHandler.Handler <object>((Action <object>)actual.Add, new object[] { "handler2" }));
objectProcessor.AddObjectHandler(new InstanceOfMatcher(typeof(String)), CreateHandler.Handler <object>((Action <object>)actual.Add, new object[] { "handler3" }));
objectProcessor.ProcessObject("string");
Assert.That(actual, Is.EqualTo(expected).AsCollection);
}
public async Task async_and_sync_handlers_should_run_in_order()
{
//TODO: This fails but not everytime... sometimes it's empty
List <object> results = new List <object> ();
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'A' }));
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'B' }));
dispatcher.AddMessageHandler(message, CreateHandler.AsyncHandler((Action <object>)results.Add, new object[] { 'C' }));
dispatcher.AddMessageHandler(message, CreateHandler.Handler((Action <object>)results.Add, new object[] { 'D' }));
dispatcher.DispatchMessage(message);
await Delay(200);
Assert.That(results, Is.EqualTo(new object[] { 'A', 'B', 'C', 'D' }).AsCollection);
}
private void CommandClearArea(IEnumerable <string> args, Position position, List <SavedPosition> savedPositions)
{
var filename = args.FirstOrDefault();
var target = position.GetAbsolutePosition(args.Skip(1).Take(3), savedPositions);
//var rotation = GetRotation(args.ElementAtOrDefault(4));
//var shift = GetPosition(args.Skip(4).Take(3));
Console.WriteLine($"outlineing {filename} to {target}");
var points = LoadFile(filename);
var results = ModelAnalyzer.Analyze(points);
var x = (target.X + results.Width / 2).ToString();
var z = (target.Z + results.Length / 2).ToString();
CreateHandler.CreateGeometry(_commandService, savedPositions, "create", "box", results.Width.ToString(),
results.Length.ToString(), results.Height.ToString(), "air", x, target.Y.ToString(), z);
}
/// <summary>
/// 初始化 IDataRecord 对象到动态对象的映射
/// </summary>
/// <param name="record"></param>
public void InitDynamicObject(IDataRecord record)
{
DynamicMethod mainMethod = new DynamicMethod("CreateDynamicObject", returnType, new Type[] { typeof(IDataRecord) }, returnType, true);
ILGenerator generator = mainMethod.GetILGenerator();
LocalBuilder result = generator.DeclareLocal(returnType);
generator.Emit(OpCodes.Newobj, returnType.GetConstructor(Type.EmptyTypes));
generator.Emit(OpCodes.Stloc, result);
for (int i = 0; i < record.FieldCount; i++)
{
string fieldName = record.GetName(i);
PropertyInfo pi = returnType.GetProperty(fieldName);
if (pi == null)
{
continue;
}
MethodInfo setMethod = pi.GetSetMethod();
// 不存在该属性或者属性无法通过set进行赋值
if (setMethod == null)
{
continue;
}
// 进行数据有效性检测
Label endMark = generator.DefineLabel();
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, i);
generator.Emit(OpCodes.Callvirt, isDbNull);
generator.Emit(OpCodes.Brtrue, endMark);
// 开始赋值操作
generator.Emit(OpCodes.Ldloc, result);
generator.Emit(OpCodes.Ldarg_0);
generator.Emit(OpCodes.Ldc_I4, i);
generator.Emit(OpCodes.Callvirt, getValue);
generator.Emit(OpCodes.Unbox_Any, record.GetFieldType(i));
generator.Emit(OpCodes.Callvirt, setMethod);
generator.MarkLabel(endMark);
}
generator.Emit(OpCodes.Ldloc, result);
generator.Emit(OpCodes.Ret);
OnCreateLoad = (CreateHandler)mainMethod.CreateDelegate(typeof(CreateHandler));
}
public Guid Create(string entity, Dictionary <string, object> values)
{
var id = CreateHandler.Execute(entity, values);
var workflowInput = new WorkflowInputParameter();
workflowInput.Values.Add("Id", id);
workflowInput.Values.Add("Values", values);
foreach (var item in CreateWorkflows
.Where(k => k.EntityLogicalName == entity)
.OrderBy(k => k.Order))
{
if (item.Action != null)
{
item.Action.Execute(this, workflowInput);
}
}
return(id);
}
private void Outline(string[] args, Position target, Position shift)
{
Rotate rotation;
var FileName = args[1];
if (args.Length == 6)
{
target.X = Convert.ToInt32(args[3]);
target.Y = Convert.ToInt32(args[4]);
target.Z = Convert.ToInt32(args[5]);
}
if (args.Length >= 5)
{
if (args[2].StartsWith("~") || args[3].StartsWith("~") || args[4].StartsWith("~"))
{
//get current position
//parse and add to current position.
_minecraftCommandService.Status("relative positions are not supported.");
return;
}
target.X = Convert.ToInt32(args[2]);
target.Y = Convert.ToInt32(args[3]);
target.Z = Convert.ToInt32(args[4]);
}
if (args.Length >= 6)
{
rotation = (Rotate)Convert.ToInt32(args?[5]);
}
if (args.Length >= 9)
{
shift.X = Convert.ToInt32(args[6]);
shift.Y = Convert.ToInt32(args[7]);
shift.Z = Convert.ToInt32(args[8]);
}
Console.WriteLine($"outlineing {FileName} to {target}");
var points = LoadFile(FileName);
var results = ModelAnalyzer.Analyze(points);
var x = (target.X + results.Width / 2).ToString();
var z = (target.Z + results.Length / 2).ToString();
CreateHandler.CreateGeometry(_minecraftCommandService, "create", "box", results.Width.ToString(), results.Length.ToString(), results.Height.ToString(), "wool", x, target.Y.ToString(), z);
}
protected override void Run(Execution <HandleContext> execution)
{
try
{
using (IHandlerInstance handler = CreateHandler.Run(execution.Context))
{
var handleContext = new HandlerContext(execution.Context.Message.Payload, handler.Current, execution.Context.Message);
BeginHandle.Run(handleContext);
new DiagnosticsWorkflow <HandlerContext>(ActualHandle).Run(handleContext);
EndHandle.Run(handleContext);
}
}
catch (Exception ex)
{
Error.Run(new ErrorContext(ex, execution.Context.Message, execution.Context.HandlerType));
throw;
}
finally
{
Finalize.Run(execution.Context);
}
}
public IActionResult Post([FromServices] CreateHandler handler, Create request)
{
handler.Handle(request);
return(Ok());
}
public ManagedRecycler(CreateHandler handler) : base(handler)
{
}
public static CreateHandler Catalog(this CreateHandler handler, string name)
{
return(() => {
return null;
});
}
public SqlPersistenceProviderFactory(NameValueCollection parameters)
{
if (parameters == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("parameters");
}
this.connectionString = null;
this.LockTimeout = TimeSpan.Zero;
this.SerializeAsText = false;
foreach (string key in parameters.Keys)
{
switch (key)
{
case connectionStringNameParameter:
ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings[parameters[key]];
if (settings == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
SR2.GetString(SR2.ConnectionStringNameIncorrect, parameters[key]));
}
this.connectionString = settings.ConnectionString;
break;
case serializeAsTextParameter:
this.SerializeAsText = bool.Parse(parameters[key]);
break;
case lockTimeoutParameter:
this.LockTimeout = TimeSpan.Parse(parameters[key], CultureInfo.InvariantCulture);
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
key,
SR2.GetString(SR2.UnknownSqlPersistenceConfigurationParameter, key, connectionStringNameParameter, serializeAsTextParameter, lockTimeoutParameter));
}
}
if (this.connectionString == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(
SR2.GetString(SR2.ConnectionStringNameParameterRequired, connectionStringNameParameter));
}
this.loadHandler = new LoadHandler(this);
this.createHandler = new CreateHandler(this);
this.updateHandler = new UpdateHandler(this);
this.unlockHandler = new UnlockHandler(this);
this.deleteHandler = new DeleteHandler(this);
}
public Pool(CreateHandler onCreate)
{
mCreateHandle = onCreate;
}
public async Task Handle_Existing_ThrowsInvalidOperation(Conteudo conteudo, [Frozen] ICollection <Conteudo> conteudos, CreateHandler subject)
{
// Arrange
conteudos.Clear();
conteudos.Add(conteudo);
var command = new Create {
Id = conteudo.Id
};
// Act
Func <Task> act = async() => await subject.Handle(command, default);
// Assert
await act.Should().ThrowAsync <InvalidOperationException>();
}
/// <summary>
/// Initializes a new instance of the <see cref="ObjectPool{T}"/> class.
/// </summary>
/// <param name="createHandler">How large buffers to allocate.</param>
public ObjectPool(CreateHandler <T> createHandler)
{
_createMethod = createHandler;
}
/// <summary>
/// 动态创建一个指定构造函数元数据的实例。
/// </summary>
/// <param name="constructorInfo">构造函数元数据。</param>
/// <param name="parameters">参数对应的值。</param>
/// <returns>返回动态创建的实例。</returns>
public static I Create(ConstructorInfo constructorInfo, params object[] parameters)
{
return((I)CreateHandler(constructorInfo)(parameters));
}
