// Use this for initialization
void Start()
{
IHandler handle2 = new Handler2();
IHandler handle1 = new Handler1(handle2);
handle1.HandleRequest(20);
}
/// <summary>
/// Initializes a new instance of the Event2 class.
/// </summary>
/// <arg name="handler"></arg>
/// <arg name="arg1"></arg>
/// <arg name="arg2"></arg>
public Event2(int evenId, Handler2 <TArg1, TArg2> handler, TArg1 arg1, TArg2 arg2)
: base(evenId)
{
this.handler = handler;
this.arg1 = arg1;
this.arg2 = arg2;
}
public void HandleMultiReturnVoid(double value1, int value2, Handler2 value3)
{
InvocationCount++;
DoubleValue = value1;
IntValue = value2;
ObjectValue = value3;
}
public void PingCheck(DateTime now)
{
lock (_clients)
{
foreach (var client in _clients)
{
if (!client.Authenticated)
{
continue; //they don't have ping shit, since they don't even send a response.
}
if (client.Pong)
{
Handler2.SendPing(client);
client.Pong = false;
client.LastPing = now;
}
else
{
if (now.Subtract(client.LastPing).TotalSeconds >= 300)
{
_pingTimeouts.Add(client);
Log.WriteLine(LogLevel.Debug, "Ping timeout from {0} ({1})", client.Username, client.Host);
}
}
}
foreach (var client in _pingTimeouts)
{
_clients.Remove(client);
client.Disconnect();
}
_pingTimeouts.Clear();
}
}
public async Task HandleIsOnlyCalledOnce()
{
var dateTimeOffset = 1;
var domainEventWrapper = new SubscribedDomainEventWrapper
{
OverallVersion = dateTimeOffset,
DomainEvent = new TestEv2(Guid.NewGuid())
};
var handleAsync = new Handler1();
var handleAsync2 = new Handler2();
var eventDelegateHandler1 = new AsyncEventHandler <Handler1, TestEv2>(
new VersionRepositoryMongoDb(EventMongoDb),
new EventFeedMock(dateTimeOffset, domainEventWrapper), handleAsync);
var eventDelegateHandler2 = new AsyncEventHandler <Handler1, TestEv2>(
new VersionRepositoryMongoDb(EventMongoDb),
new EventFeedMock(dateTimeOffset, domainEventWrapper), handleAsync2);
await eventDelegateHandler1.UpdateAsync();
await eventDelegateHandler2.UpdateAsync();
Assert.AreEqual(1, handleAsync.TimesCalled);
Assert.AreEqual(1, handleAsync2.TimesCalled);
}
static void Main(string[] args)
{
Counter counter = new Counter();
Handler1 handler1 = new Handler1();
Handler2 handler2 = new Handler2();
counter.OnValueReached += handler1.Message;
counter.OnValueReached += handler2.Message;
counter.Count(30);
}
public void UpdateClientTime(DateTime dateTime)
{
lock (_clients)
{
foreach (var kvp in _clientsByName.Values)
{
Handler2.SendClientTime(kvp, dateTime);
}
}
}
public void OneIngameLoginLoad()
{
UpdateFriendsStatus(true, Client); //Write Later As Event
WriteBlockList();
LoadMasterList();
SendReciveMasterCoper();
/*
* LoadGuild();*/
Handler2.SendClientTime(Client, DateTime.Now);
}
static void UseEvent()
{
ClassCounter Counter = new ClassCounter();
Handler1 Handler1 = new Handler1();
Handler2 Handler2 = new Handler2();
Counter.onCount += Handler1.Message;
Counter.onCount += Handler2.Message;
//Запустили счетчик
Counter.Counter();
}
public void HandleSinglePrimitiveReturnVoidPerf()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleSinglePrimitiveReturnVoid");
Invoke(handler, method, 1.0d);
Assert.Equal(1.0d, handler.DoubleValue);
}
static void Main()
{
MyStopWatch stopwatch = new MyStopWatch();
Handler1 handler1 = new Handler1();
Handler2 handler2 = new Handler2();
Handler3 handler3 = new Handler3();
stopwatch.Event += handler1.OnTimer;
stopwatch.Event += handler2.OnTimer;
stopwatch.Event += handler3.OnTimer;
stopwatch.Start(new TimeSpan(0, 0, 5));
}
public void HandleNullablePrimitive()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleNullablePrimitive");
var result = Invoke(handler, method, 10, "stringArg");
Assert.Equal(1, handler.InvocationCount);
Assert.Equal("10-stringArg", result);
}
public async Task HandleAsyncStringMethod()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleAsyncStringMethod");
var result = Invoke(handler, method, 10, "stringArg") as Task <string>;
var str = await result;
Assert.Equal(1, handler.InvocationCount);
Assert.Equal("10-stringArg", str);
}
public void HandleMultiReturnVoid()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleMultiReturnVoid");
Invoke(handler, method, 1.0d, 2, handler);
Assert.Equal(1.0d, handler.DoubleValue);
Assert.Equal(2, handler.IntValue);
Assert.Same(handler, handler.ObjectValue);
}
public async Task HandleAsyncVoidMethod()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleAsyncVoidMethod");
var result = Invoke(handler, method, 1.0d) as Task;
await result;
Assert.Equal(1, handler.InvocationCount);
Assert.Equal(1.0d, handler.DoubleValue);
}
public void Should_resolve_instance_of_Handler2_and_return_it()
{
// Arrange
var expectedHandler = new Handler2();
var convention = new DefaultPolicyViolationHandlerIsOfTypeConvention <Handler2>();
convention.PolicyViolationHandlerProvider = t => expectedHandler;
var exception = TestDataFactory.CreateExceptionFor(new IgnorePolicy());
// Act
var handler = convention.GetHandlerFor(exception);
// Assert
Assert.That(handler, Is.EqualTo(expectedHandler));
}
public void ComparePerfHandleSinglePrimitiveReturnVoid()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleSinglePrimitiveReturnVoid");
var ticks1 = TimedInvoke(handler, method, 100_000, 1.0d);
Assert.Equal(100_000, handler.InvocationCount);
var ticks2 = TimedReflectionInvoke(handler, method, 100_000, 1.0d);
Assert.Equal(200_000, handler.InvocationCount);
Assert.True(ticks2 > ticks1);
}
static void Main(string[] args)
{
WriteArguments(args);
Handler1 handler1 = new Handler1();
Handler2 handler2 = new Handler2();
Handler3 handler3 = new Handler3();
MyServiceNormal myServiceNormal = new MyServiceNormal(handler1, handler2, handler3);
myServiceNormal.DoSomething();
WriteSeparator();
HandlerMediator handlerMediator = new HandlerMediator(handler1, handler2, handler3);
MyServiceWithMediator myServiceWithMediator = new MyServiceWithMediator(handlerMediator);
myServiceWithMediator.DoSomething();
}
public bool TryGetHandler(out IHttpHandler handler)
{
var count = _collection.Count;
if (count == 0)
{
handler = null;
return(true);
}
else if (count == 1)
{
handler = _collection[0];
return(true);
}
else if (count == 2)
{
handler = new Handler2(_collection[0], _collection[1]);
return(true);
}
else if (count == 3)
{
handler = new Handler3(_collection[0], _collection[1], _collection[2]);
return(true);
}
else if (count == 4)
{
handler = new Handler4(_collection[0], _collection[1], _collection[2], _collection[3]);
return(true);
}
else if (count == 5)
{
handler = new Handler5(_collection[0], _collection[1], _collection[2], _collection[3], _collection[4]);
return(true);
}
else
{
handler = null;
return(false);
}
}
/// <summary>
/// 异步调用
/// </summary>
public void DoAsynAction()
{
Handler1 handler1 = new Handler1(AsynDemo1);
handler1.BeginInvoke(null, null);
Handler2 handler2 = new Handler2(AsynDemo2);
handler2.BeginInvoke("string", null, null);
Handler3 handler3 = new Handler3(AsynDemo3);
//handler3.BeginInvoke(null, null);
IAsyncResult result3 = handler3.BeginInvoke(null, null);
Handler4 handler4 = new Handler4(AsynDemo4);
//handler4.BeginInvoke("string", null, null);
IAsyncResult result4 = handler4.BeginInvoke("string", null, null);
Handler5 handler5 = new Handler5(AsynDemo5);
//handler5.BeginInvoke("", 0, null, null);
IAsyncResult result5 = handler5.BeginInvoke("string", 0, null, null);
}
public async Task AddRebus_ConfigurePolymorphicMessageHandling_AllMessagesAreHandled()
{
// Arrange
var services = new ServiceCollection();
var testHandler1 = new Handler1(2);
var testHandler2 = new Handler2(2);
// Act
services
.AddSingleton <IHandleMessages <Message1> >(testHandler1)
.AddSingleton <IHandleMessages <MessageBase> >(testHandler2)
.AddRebus(config => config
.Logging(l => l.None())
.Transport(t => t.UseInMemoryTransport(new InMemNetwork(false), "Messages"))
.Routing(r => r.TypeBased().MapAssemblyOf <Message1>("Messages")));
var provider = services
.BuildServiceProvider()
.UseRebus();
var rebus = provider.GetRequiredService <IBus>();
await rebus.Send(new Message1());
await rebus.Send(new Message1());
// Assert
await Task.WhenAny(testHandler1.CountReached, Task.Delay(3000));
await Task.WhenAny(testHandler2.CountReached, Task.Delay(3000));
(provider.GetRequiredService <IHandleMessages <Message1> >() as Handler1)
.HandleCount.Should().Be(2);
(provider.GetRequiredService <IHandleMessages <MessageBase> >() as Handler2)
.HandleCount.Should().Be(2);
}
public MyServiceNormal(Handler1 handler1, Handler2 handler2, Handler3 handler3)
{
_handler1 = handler1;
_handler2 = handler2;
_handler3 = handler3;
}
public void EventUtility_Raise_5()
{
Handler2.Raise();
}
public void EventUtility_Raise_4()
{
Handler2.Raise(this);
}
public void EventUtility_Raise_2()
{
CancelEventArgs args = new CancelEventArgs();
Handler2.Raise(this, args);
}
public RequestHandler2 <T, TR> Handle(Handler2 handler)
{
_executor = (request, param1, param2, mediaTypeMapper1, errorHandler1, logger1)
=> RequestExecutor.ExecuteRequest(() => handler.Invoke(param1, param2), errorHandler1, logger1);
return(this);
}
/// <summary>
/// Create an event with 2 arguments.
/// </summary>
/// <typearg name="TArg1"></typearg>
/// <typearg name="TArg2"></typearg>
/// <arg name="handler"></arg>
/// <arg name="arg1"></arg>
/// <arg name="arg2"></arg>
/// <returns></returns>
public static EventBase CreateEvent <TArg1, TArg2>(int eventId, Handler2 <TArg1, TArg2> handler, TArg1 arg1, TArg2 arg2)
{
return(new Event2 <TArg1, TArg2>(eventId, handler, arg1, arg2));
}
