public void RequestGeneratorRetrieveTest()
{
IRequestGenerator requestGenerator = new WebRequestGenerator();
const string TestUri = "http://beta-api.etsy.com/v1/listings/featured/front?offset=0&limit=10&detail_level=low&api_key=" +
NetsyData.EtsyApiKey;
string resultString = string.Empty;
Exception ex = null;
using (AutoResetEvent waitEvent = new AutoResetEvent(false))
{
Action<string> successAction = s =>
{
resultString = s;
waitEvent.Set();
};
Action<Exception> errorAction = e =>
{
ex = e;
waitEvent.Set();
};
requestGenerator.StartRequest(new Uri(TestUri), successAction, errorAction);
bool signalled = waitEvent.WaitOne(Constants.WaitTimeout);
Assert.IsTrue(signalled);
Assert.IsFalse(string.IsNullOrEmpty(resultString));
Assert.IsNull(ex);
}
}
public void TestDelete()
{
FileInfo file = new FileInfo(@"d:\X16-42552VS2010UltimTrial1.txt");
AutoResetEvent are = new AutoResetEvent(false);
string key = null;
HttpCommunicate.Upload(file, (result, warning) =>
{
Console.WriteLine("result:" + result);
key = result + "";
are.Set();
}, error =>
{
Console.WriteLine("error:" + error);
are.Set();
});
are.WaitOne();
are.Reset();
FileDeletePackage package = new FileDeletePackage();
package.key = key;
HttpCommunicate.Request(package, (result, warning) =>
{
Console.WriteLine("file:" + result);
are.Set();
}, error =>
{
Console.WriteLine("error:" + error);
are.Set();
});
are.WaitOne();
}
static void Main(string[] args)
{
using (WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
// Add ChannelManager
ChannelManagerService channelmgr = new ChannelManagerService();
workflowRuntime.AddService(channelmgr);
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e) { Console.WriteLine("WorkflowCompleted: " + e.WorkflowInstance.InstanceId.ToString()); waitHandle.Set(); };
workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e) { Console.WriteLine("WorkflowTerminated: " + e.Exception.Message); waitHandle.Set(); };
while (true)
{
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(Microsoft.WorkflowServices.Samples.SequentialCalculatorClient));
Console.WriteLine("Start SequentialCalculatorClient.");
instance.Start();
waitHandle.WaitOne();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Do another calculation? (Y)");
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Press <enter> to exit.");
Console.ResetColor();
string input = Console.ReadLine();
if (input.Length == 0 || input[0] != 'Y')
break;
waitHandle.Reset();
}
}
}
public void Do_Timeout()
{
var sw = Stopwatch.StartNew();
const int ms = 100;
var i = 0;
var ellapsed = 0L;
var wait = new AutoResetEvent(false);
Do.Timeout(() =>
{
ellapsed = sw.ElapsedMilliseconds;
i++;
wait.Set();
}, ms);
if (wait.WaitOne(ms * 3))
{
Assert.AreEqual(1, i);
Assert.IsTrue(ellapsed > ms * .9);
} else
{
Assert.Fail("callback not executed.");
}
sw.Restart();
var killswitch = Do.Timeout(() => { wait.Set(); }, ms * 2);
killswitch.Kill();
ellapsed = sw.ElapsedMilliseconds;
Assert.IsTrue(ellapsed < ms * 2);
if (wait.WaitOne(ms * 4))
{
Assert.Fail("Unable to stop timeout.");
}
}
static void Main(string[] args)
{
using(WorkflowRuntime workflowRuntime = new WorkflowRuntime())
{
AutoResetEvent waitHandle = new AutoResetEvent(false);
workflowRuntime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e)
{
Console.WriteLine("Workflow completed.");
waitHandle.Set();
};
workflowRuntime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
{
Console.WriteLine(e.Exception.Message);
waitHandle.Set();
};
WorkflowInstance instance = workflowRuntime.CreateWorkflow(typeof(StateInitialization.SampleWorkflow));
Console.WriteLine("Starting workflow.");
instance.Start();
waitHandle.WaitOne();
workflowRuntime.StopRuntime();
}
}
public void Test_SendToWrongPort()
{
IPEndPoint ep1 = new IPEndPoint (IPAddress.Parse ("10.0.0.1"), 10000);
IPEndPoint ep2 = new IPEndPoint (IPAddress.Parse ("10.0.0.2"), 10000);
VirtualNetwork network = new VirtualNetwork (LatencyTypes.Constant (20), 5, PacketLossType.Lossless (), 2);
byte[] msg = new byte[]{0, 1, 2, 3};
try {
using (AutoResetEvent done = new AutoResetEvent (false))
using (VirtualDatagramEventSocket sock1 = new VirtualDatagramEventSocket (network, ep1.Address))
using (VirtualDatagramEventSocket sock2 = new VirtualDatagramEventSocket (network, ep2.Address)) {
sock1.Bind (new IPEndPoint (IPAddress.Any, ep1.Port));
sock2.Bind (new IPEndPoint (IPAddress.Any, ep2.Port));
sock1.Received += new DatagramReceiveEventHandler (delegate (object sender, DatagramReceiveEventArgs e) {
done.Set ();
});
sock2.Received += new DatagramReceiveEventHandler (delegate (object sender, DatagramReceiveEventArgs e) {
done.Set ();
});
sock1.SendTo (msg, new IPEndPoint (ep2.Address, ep2.Port + 1));
Assert.IsFalse (done.WaitOne (500));
sock2.SendTo (msg, ep1);
Assert.IsTrue (done.WaitOne ());
}
} finally {
network.Close ();
}
}
public static ITileSource Build(
string urlToTileMapXml,
bool overrideTmsUrlWithUrlToTileMapXml)
{
var webRequest = (HttpWebRequest) WebRequest.Create(urlToTileMapXml);
var waitHandle = new AutoResetEvent(false);
ITileSource tileSource = null;
Exception error = null;
var state = new object[]
{
new Action<Exception>(ex =>
{
error = ex;
waitHandle.Set();
}),
new Action<ITileSource>(ts =>
{
tileSource = ts;
waitHandle.Set();
}),
webRequest,
urlToTileMapXml,
overrideTmsUrlWithUrlToTileMapXml
};
webRequest.BeginGetResponse(LoadTmsLayer, state);
waitHandle.WaitOne();
if (error != null) throw error;
return tileSource;
}
static int Main(string[] args)
{
var finishedProcessing = new AutoResetEvent(false);
int returnCode = 0;
var index = new IndexFiles();
index.Out_Statistics += stats =>
{
System.Console.WriteLine("Successfully indexed {0} words.", stats.WordCount);
returnCode = 0;
finishedProcessing.Set();
};
index.Out_ValidationError += err =>
{
System.Console.WriteLine("*** Aborted indexing! Validation error: {0}", err);
returnCode = 1;
finishedProcessing.Set();
};
index.Out_UnhandledException += ex =>
{
System.Console.WriteLine("*** Aborted indexing! Unexpected exception: {0}. See log for details.", ex.Message);
returnCode = 99;
finishedProcessing.Set();
};
System.Console.WriteLine("Indexing files in {0} [Thread {1}]", args[0], Thread.CurrentThread.GetHashCode());
index.Index(args[0], args[1]);
finishedProcessing.WaitOne();
return returnCode;
}
public static void Stop()
{
bRun = false;
for (int i = 0; i < ThreadHandle.Length; i++)
{
AEvent.Set();
Thread.Sleep(10);
}
for (int i = 0; i < ThreadHandle.Length; i++)
{
try
{
if (ThreadHandle[i].ThreadState != ThreadState.Stopped)
{
ThreadHandle[i].Abort();
}
}
catch
{
}
}
if (AEvent != null)
{
AEvent.Close();
}
}
public void should_consume_with_valid_consumer()
{
int result = 0;
var waitHandle = new AutoResetEvent(false);
IBus producer = this.StartBus(
"producer",
cfg =>
{
Func<IRouteResolverBuilder, IRouteResolver> routeResolverBuilder = b => b.Topology.Declare(Exchange.Named("multi.exchange"));
cfg.Route("boo.request")
.ConfiguredWith(routeResolverBuilder);
cfg.Route("foo.request")
.ConfiguredWith(routeResolverBuilder);
});
this.StartBus(
"consumer",
cfg =>
{
Func<ISubscriptionEndpointBuilder, ISubscriptionEndpoint> subscriptionBuilder = b =>
{
Exchange e = b.Topology.Declare(Exchange.Named("multi.exchange"));
Queue q = b.Topology.Declare(Queue.Named("multi.queue"));
b.Topology.Bind(e, q);
return new SubscriptionEndpoint(q, e);
};
cfg.On<BooMessage>("boo.request")
.ReactWith(
(m, ctx) =>
{
result = m.Num;
waitHandle.Set();
})
.WithEndpoint(subscriptionBuilder);
cfg.On<FooMessage>("foo.request")
.ReactWith(
(m, ctx) =>
{
result = m.Num * 2;
waitHandle.Set();
})
.WithEndpoint(subscriptionBuilder);
});
producer.Emit("boo.request", new BooMessage(13));
waitHandle.WaitOne(5.Seconds()).Should().BeTrue();
result.Should().Be(13);
producer.Emit("foo.request", new FooMessage(13));
waitHandle.WaitOne(5.Seconds()).Should().BeTrue();
result.Should().Be(26);
}
public void TestDisconnect()
{
var ev = new AutoResetEvent(false);
var succeeded = false;
var communicationLayer = new SocketConnection();
communicationLayer.ConnectionSucceeded += () =>
{
succeeded = true;
ev.Set();
};
communicationLayer.ErrorOccurred += (msg) =>
{
succeeded = false;
ev.Set();
};
communicationLayer.StartConnect("localhost", 80);
ev.WaitOne(5000);
Assert.IsTrue(succeeded);
var disconnectEv = new AutoResetEvent(false);
communicationLayer.ServerDisconnected += () => disconnectEv.Set();
communicationLayer.StartDisconnect();
disconnectEv.WaitOne(5000);
Assert.IsFalse(communicationLayer.Connected);
}
public async Task Test_QueueUrl_AlreadyQueued1 ()
{
var bus = new InProcessBus ();
var repo = new DownloadRepositoryMock ();
var manager = new DownloadManager.iOS.DownloadManager (bus, repo);
var wait1 = new AutoResetEvent (false);
bool alreadyQueued = false;
bool checkFreeSlot = false;
bus.Subscribe<AlreadyQueued> (p => {
alreadyQueued = true;
wait1.Set();
});
bus.Subscribe<CheckFreeSlot> (p => {
checkFreeSlot = true;
wait1.Set();
});
repo.Insert(new Download {
Url = "http://url.com/download/file.zip"
});
manager.QueueUrl (new QueueUrl {
Url = "http://url.com/download/file.zip"
});
wait1.WaitOne ();
Assert.AreEqual (false, checkFreeSlot);
Assert.AreEqual (true, alreadyQueued);
}
public void Intercept(IInvocation invocation)
{
var circuitName = invocation.Method.DeclaringType.Name;
// Setup a new circuit if needed
if (!_circuits.ContainsKey(circuitName))
{
_circuits.Add(circuitName, new Circuit());
}
var circuit = _circuits[circuitName];
// If the circuit breaker has been tripped, fail fast
if (circuit.IsOffline)
{
throw new Exception("This service is misbehaving and has been taken offline");
}
// The circuit breaker hasn't been tripped - allow it
try
{
var autoReset = new AutoResetEvent(false);
var exception = null as Exception;
ThreadPool.QueueUserWorkItem(
thread =>
{
try
{
invocation.Proceed();
autoReset.Set();
}
catch (Exception innerException)
{
exception = innerException;
autoReset.Set();
}
});
var success = autoReset.WaitOne(3000);
if (!success)
{
// It timed out
circuit.RecordTimeout();
throw new TimeoutException("The call timed out");
}
if (exception != null)
{
throw exception;
}
}
catch (TimeoutException)
{
throw;
}
catch (Exception ex)
{
circuit.RecordException(ex);
throw;
}
}
/// <summary>
/// Create a Pusher Client, and subscribes a user
/// </summary>
/// <param name="pusherServer">Server to connect to</param>
/// <param name="reset">The AutoReset to control the subscription by the client</param>
/// <param name="channelName">The name of the channel to subscribe to</param>
/// <returns>A subscribed client</returns>
public static PusherClient.Pusher CreateClient(Pusher pusherServer, AutoResetEvent reset, string channelName)
{
PusherClient.Pusher pusherClient =
new PusherClient.Pusher(Config.AppKey, new PusherClient.PusherOptions()
{
Authorizer = new InMemoryAuthorizer(
pusherServer,
new PresenceChannelData()
{
user_id = "Mr Pusher",
user_info = new { twitter_id = "@pusher" }
})
});
pusherClient.Connected += delegate { reset.Set(); };
pusherClient.Connect();
reset.WaitOne(TimeSpan.FromSeconds(5));
var channel = pusherClient.Subscribe(channelName);
channel.Subscribed += delegate { reset.Set(); };
reset.WaitOne(TimeSpan.FromSeconds(5));
return pusherClient;
}
private void Channel_HostInfoUpdated(object sender, EventArgs e)
{
SyncContext.Post(dummy => {
hostInfoUpdated = true;
changedEvent.Set();
}, null);
}
public static void SearchingWithCancellation()
{
Demo.DisplayHeader("Creating async observable with async-await and cancellation");
var exampleResetEvent = new AutoResetEvent(false);
// Change the index to when you want the subscription disposed
int cancelIndex = 1;
var results = SearchEngineExample.Search_WithCancellation("Rx");
IDisposable subscription = Disposable.Empty;
subscription = results
.Select((result, index) => new { result, index }) //adding the item index to the notification
.Do(x =>
{
if (x.index == cancelIndex)
{
Console.WriteLine("Cancelling on index {0}", cancelIndex);
subscription.Dispose();
exampleResetEvent.Set();
}
})
.Select(x => x.result) //rollback the observable to be IObservable<string>
.DoLast(() => exampleResetEvent.Set(), delay: TimeSpan.FromSeconds(1))
.SubscribeConsole("results");
exampleResetEvent.WaitOne();
}
static void Main(string[] args)
{
m_WebSockets = new WebSocket[1000];
var autoEventReset = new AutoResetEvent(false);
for(var i = 0; i < m_WebSockets.Length; i++)
{
var websocket = new WebSocket("ws://localhost:2011/");
websocket.Opened += (s, e) =>
{
autoEventReset.Set();
};
websocket.Error += (s, e) =>
{
Console.WriteLine(e.Exception.Message);
autoEventReset.Set();
};
websocket.MessageReceived += new EventHandler<MessageReceivedEventArgs>(websocket_MessageReceived);
websocket.Open();
autoEventReset.WaitOne();
m_WebSockets[i] = websocket;
Console.WriteLine(i);
}
Console.WriteLine("All connected");
Console.ReadLine();
}
public void DispatchActionToMainWindow(Action message)
{
bool loaded = false;
if (Application.Current.Dispatcher.HasShutdownStarted)
message();
Application.Current.Dispatcher.Invoke(new Action(() =>
{
if (Application.Current.MainWindow != null)
{
loaded = Application.Current.MainWindow.IsLoaded;
return;
}
loaded = false;
}));
if (!loaded)
{
var handle = new AutoResetEvent(false);
EventHandler set = delegate { handle.Set(); };
Application.Current.Dispatcher.Invoke(
new Action(() =>
{
if (Application.Current.MainWindow != null)
Application.Current.MainWindow.Loaded += (sender, args) => handle.Set();
else
Application.Current.Activated += set;
}));
handle.WaitOne();
Application.Current.Activated -= set;
}
Application.Current.Dispatcher.Invoke(message);
}
public void CurrentIsVisibleAccrossThreads()
{
var sqlCharacters = new TestSqlCharacters();
SqlCharacters actual = null;
var handle = new AutoResetEvent(false);
var thread1 = new Thread(() =>
{
SqlCharacters.Current = sqlCharacters;
handle.Set();
});
var thread2 = new Thread(() =>
{
actual = SqlCharacters.Current;
handle.Set();
});
thread1.Start();
handle.WaitOne();
thread2.Start();
handle.WaitOne();
thread1.Abort();
thread2.Abort();
Assert.Same(sqlCharacters, actual);
}
public void when_receiving_message_then_can_send_new_message()
{
var secondReceiver = new TestableMessageReceiver(this.connectionFactory);
this.sender.Send(new Message("message1"));
var waitEvent = new AutoResetEvent(false);
string receiver1Message = null;
string receiver2Message = null;
this.receiver.MessageReceived += (s, e) =>
{
waitEvent.Set();
receiver1Message = e.Message.Body;
waitEvent.WaitOne();
};
secondReceiver.MessageReceived += (s, e) =>
{
receiver2Message = e.Message.Body;
};
ThreadPool.QueueUserWorkItem(_ => { this.receiver.ReceiveMessage(); });
Assert.IsTrue(waitEvent.WaitOne(TimeSpan.FromSeconds(10)));
this.sender.Send(new Message("message2"));
secondReceiver.ReceiveMessage();
waitEvent.Set();
Assert.IsTrue("message1" == receiver1Message);
Assert.IsTrue("message2" == receiver2Message);
}
public void MessageAfterExceptionTest()
{
Exception e = null;
AutoResetEvent even = new AutoResetEvent(false);
int y = 0;
var a = new Arbitr<Message, NOPMessage>(
(z) =>
{
y = 1 / z.x;
even.Set();
},
(z) =>
{
e = z;
even.Set();
});
a.Send(new Message() { x = 0 });
bool completed = even.WaitOne(500);
Assert.IsTrue(completed);
Assert.IsNotNull(e);
Assert.AreEqual(y, 0);
e = null;
a.Send(new Message() { x = 1 });
completed = even.WaitOne(500);
Assert.IsTrue(completed);
Assert.IsNull(e);
Assert.AreEqual(y, 1);
}
/// <summary>
/// Send an object to the channel. Blocks until there is room to send or the channel is closed.
/// </summary>
public void Send(T t)
{
start:
if (closing)
{
return;
}
lock (qlock)
{
int c = queue.Count;
if (backlog > 0 && c >= backlog)
{
goto wait;
}
if (closing)
{
return;
}
queue.Enqueue(t);
reset.Set();
return;
}
wait:
if (ShiftOnFull)
{
Receive();
}
resetR.WaitOne();
goto start;
}
static void Main(string[] args)
{
AutoResetEvent syncEvent = new AutoResetEvent(false);
// create the workflow app and add handlers for the Idle and Completed actions
WorkflowApplication app = new WorkflowApplication(new Sequence1());
app.Idle = delegate(WorkflowApplicationIdleEventArgs e)
{
syncEvent.Set();
};
app.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
syncEvent.Set();
};
// start the application
app.Run();
syncEvent.WaitOne();
// read some text from the console and resume the readText bookmark (created in the first WaitForInput activity)
string text = Console.ReadLine();
app.ResumeBookmark("readText", text);
syncEvent.WaitOne();
// read some text from the console, convert it to number, and resume the readNumber bookmark (created in the second WaitForInput activity)
int number = ReadNumberFromConsole();
app.ResumeBookmark("readNumber", number);
syncEvent.WaitOne();
Console.WriteLine("");
Console.WriteLine("Press [ENTER] to exit...");
Console.ReadLine();
}
/// <summary>
/// Считает время ожидания ответа на запрос к http серверу
/// </summary>
/// <param name="address">Url адрес</param>
/// <param name="maxRequestTime">Максимальное время ожидания ответа. -1 для бесконечного времени ожидания.</param>
/// <returns>Время запроса в мс</returns>
internal static int GetRequestTime(string address, RequestParams requestParams, int maxRequestTime, out Exception outEx)
{
int result = -1;
Exception innerEx = null;
using (var request = new HttpRequest())
{
request.UserAgent = HttpHelper.ChromeUserAgent();
EventWaitHandle wh = new AutoResetEvent(false);
var requestThread = new Thread(() =>
{
var watch = new Stopwatch();
watch.Start();
try
{
string resultPage = request.Get(address, requestParams).ToString();
}
catch (Exception ex) { innerEx = ex; }
result = Convert.ToInt32(watch.ElapsedMilliseconds);
watch.Reset();
wh.Set();
});
requestThread.Start();
var stoptimer = new System.Threading.Timer((Object state) =>
{
requestThread.Abort();
wh.Set();
}, null, maxRequestTime, Timeout.Infinite);
wh.WaitOne();
stoptimer.Dispose();
}
outEx = innerEx;
return result;
}
public void Test_Add_and_Retrieve()
{
var testBooking = CreateTestBooking();
Booking actual = null;
var waiter = new AutoResetEvent(false);
_client.AddBookingAsync(testBooking, booking =>
{
actual = booking;
waiter.Set();
});
Assert.IsTrue(waiter.WaitOne(1000), "Timeout waiting for WCF asynk result");
Assert.AreNotSame(testBooking, actual, "WCF trip over the wire should have created a new object through serialisation");
//Test that Get the saved booking works over WCF
IEnumerable<Booking> actualBookings = null;
waiter.Reset();
_client.GetBookingsAsync(DateTime.Now, bookings =>
{
actualBookings = bookings;
waiter.Set();
});
Assert.IsTrue(waiter.WaitOne(1000), "Timeout waiting for WCF asynk result");
var retrievedBooking = actualBookings.FirstOrDefault();
Assert.IsNotNull(retrievedBooking, "Bookings should contain created booking");
Assert.AreEqual(testBooking.Id, retrievedBooking.Id, "Id is not persisted corectly");
Assert.AreEqual(testBooking.ClientName, retrievedBooking.ClientName, "ClientName is not persisted corectly");
Assert.AreEqual(testBooking.Duration, retrievedBooking.Duration, "Duration is not persisted corectly");
Assert.AreEqual(testBooking.Slot, retrievedBooking.Slot, "Slot is not persisted corectly");
}
static void Main()
{
try
{
waitHandle = new AutoResetEvent(false);
DataAccess.CreateAndInsertTrackingProfile();
using (WorkflowRuntime runtime = new WorkflowRuntime())
{
SqlTrackingService trackingService = new SqlTrackingService(DataAccess.connectionString);
/*
* Set partitioning settings on Sql Tracking Service and database
*/
//Turn on PartitionOnCompletion setting-- Default is false
trackingService.PartitionOnCompletion = true;
//Set partition interval-- Default is 'm' (monthly)
DataAccess.SetPartitionInterval('d');
runtime.AddService(trackingService);
runtime.StartRuntime();
runtime.WorkflowCompleted += delegate(object sender, WorkflowCompletedEventArgs e)
{
waitHandle.Set();
};
runtime.WorkflowTerminated += delegate(object sender, WorkflowTerminatedEventArgs e)
{
Console.WriteLine(e.Exception.Message);
waitHandle.Set();
};
WorkflowInstance instance = runtime.CreateWorkflow(typeof(SimpleWorkflow));
instance.Start();
waitHandle.WaitOne();
runtime.StopRuntime();
DataAccess.GetWorkflowTrackingEvents(instance.InstanceId);
Console.WriteLine("\nDone running the workflow.");
/*
* Show tracking partition information and tables
*/
DataAccess.ShowTrackingPartitionInformation();
DataAccess.ShowPartitionTableInformation();
}
}
catch (Exception ex)
{
if (ex.InnerException != null)
Console.WriteLine(ex.InnerException.Message);
else
Console.WriteLine(ex.Message);
}
}
public bool TryProcess(CommandProcessorContext context, string[] args, out int exitCode)
{
var commandName = args[0].ToUpper();
var commandArgs = args.Skip(1).ToArray();
ICmdProcessor commandProcessor;
if (!_processors.TryGetValue(commandName, out commandProcessor))
{
_log.Info("Unknown command: {0}.", commandName);
if (_regCommandsProcessor != null)
_regCommandsProcessor.Execute(context, new string[0]);
exitCode = 1;
return false;
}
int exitC = 0;
var executedEvent = new AutoResetEvent(false);
ThreadPool.QueueUserWorkItem(_ =>
{
try
{
var syntaxOk = commandProcessor.Execute(context, commandArgs);
if (syntaxOk)
{
exitC = context.ExitCode;
}
else
{
exitC = 1;
_log.Info("Usage of {0}:{1}{2}", commandName, Environment.NewLine, commandProcessor.Usage);
}
executedEvent.Set();
}
catch (Exception exc)
{
_log.ErrorException(exc, "Error while executing command {0}.", commandName);
exitC = -1;
executedEvent.Set();
}
});
executedEvent.WaitOne(1000);
context.WaitForCompletion();
if (!string.IsNullOrWhiteSpace(context.Reason))
_log.Error("Error during execution of command: {0}.", context.Reason);
if (context.Error != null)
{
_log.ErrorException(context.Error, "Error during execution of command");
var details = new StringBuilder();
BuildFullException(context.Error, details);
_log.Error("Details: {0}", details.ToString());
}
exitCode = exitC == 0 ? context.ExitCode : exitC;
return true;
}
public void MultipleSet ()
{
AutoResetEvent evt = new AutoResetEvent (true);
Assertion.AssertEquals ("#01", true, evt.WaitOne (1000, false));
evt.Set ();
evt.Set ();
Assertion.AssertEquals ("#02", true, evt.WaitOne (1000, false));
Assertion.AssertEquals ("#03", false, evt.WaitOne (1000, false));
}
public void MultipleSet ()
{
AutoResetEvent evt = new AutoResetEvent (true);
Assert.IsTrue (evt.WaitOne (1000, false), "#1");
evt.Set ();
evt.Set ();
Assert.IsTrue (evt.WaitOne (1000, false), "#2");
Assert.IsFalse (evt.WaitOne (1000, false), "#3");
}
static void Main(string[] args)
{
string baseAddress = "http://" + Environment.MachineName + ":8000/Service";
ServiceHost host = new ServiceHost(typeof(Service), new Uri(baseAddress));
host.AddServiceEndpoint(typeof(ITest), new BasicHttpBinding(), "");
host.Open();
WriteLine("Host opened");
ChannelFactory<ITest> factory = new ChannelFactory<ITest>(new BasicHttpBinding(), new EndpointAddress(baseAddress));
ITest proxy = factory.CreateChannel();
WriteLine("Add(4, 5): {0}", proxy.Add(4, 5));
WriteLine("Add(4, 5): {0}", proxy.Add(4, 5));
AutoResetEvent evt = new AutoResetEvent(false);
proxy.BeginPower(2, 64, delegate(IAsyncResult asyncResult)
{
WriteLine("Pow(2, 64): {0}", proxy.EndPower(asyncResult));
evt.Set();
}, null);
evt.WaitOne();
proxy.BeginPower(2, 64, delegate(IAsyncResult asyncResult)
{
WriteLine("Pow(2, 64): {0}", proxy.EndPower(asyncResult));
evt.Set();
}, null);
evt.WaitOne();
WriteLine("Reverse(\"Hello world\"): {0}", proxy.Reverse("Hello world"));
WriteLine("Reverse(\"Hello world\"): {0}", proxy.Reverse("Hello world"));
int i;
WriteLine("TryParseInt(123): {0}, {1}", proxy.TryParseInt("123", out i), i);
WriteLine("TryParseInt(123): {0}, {1}", proxy.TryParseInt("123", out i), i);
proxy.BeginTryParseDouble("34.567", delegate(IAsyncResult asyncResult)
{
double dbl;
WriteLine("TryParseDouble(34.567): {0}, {1}", proxy.EndTryParseDouble(out dbl, asyncResult), dbl);
evt.Set();
}, null);
evt.WaitOne();
proxy.BeginTryParseDouble("34.567", delegate(IAsyncResult asyncResult)
{
double dbl;
WriteLine("TryParseDouble(34.567): {0}, {1}", proxy.EndTryParseDouble(out dbl, asyncResult), dbl);
evt.Set();
}, null);
evt.WaitOne();
WriteLine("Press ENTER to close");
Console.ReadLine();
host.Close();
}
public static Control showAscxInForm(Type controlType, string formTitle, int width = -1, int height = -1, bool startHidden = false)
{
var controlCreation = new AutoResetEvent(false);
Control control = null;
O2Thread.staThread(
()=> {
O2Gui o2Gui = null;
try
{
control = (Control)PublicDI.reflection.createObjectUsingDefaultConstructor(controlType);
if (control != null)
{
control.Dock = DockStyle.Fill;
o2Gui = new O2Gui(width, height) ; // I might need to adjust these width, height so that the control is the one with this size (and not the hosting form)
o2Gui.Text = formTitle;
if (width > -1)
control.Width = width;
else
o2Gui.Width = control.Width; // if it is not defined resize the form to fit the control
if (height > -1)
control.Height = height;
else
o2Gui.Height = control.Height; // if it is not defined resize the form to fit the control
o2Gui.clientSize(control.Width, o2Gui.Height); // reset the form size to the control's size
o2Gui.Controls.Add(control);
o2Gui.Load += (sender, e) => controlCreation.Set();
if (startHidden) // very useful from UnitTests and cases where more should be added to the UI before showing it
{
o2Gui.Opacity = 0;
o2Gui.ShowInTaskbar = false;
}
o2Gui.showDialog(false);
}
else
controlCreation.Set();
}
catch (Exception ex)
{
"in showAscxInForm: {0}".format(ex).error();
controlCreation.Set();
}
finally
{
if (o2Gui != null)
o2Gui.Dispose();
}
});
var maxTimeOut = System.Diagnostics.Debugger.IsAttached ? -1 : 20000;
if (controlCreation.WaitOne(maxTimeOut).failed())
"[WinForms] Something went wrong with the creation of the {0} control with title '{1}' since it took more than 20s to start".error(controlType, formTitle);
return control;
}
private void DrawRectangle()
{
autoResetEvent.WaitOne();
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine(" *****");
Console.WriteLine(" *****");
Console.WriteLine(" *****");
Console.ResetColor();
autoResetEvent.Set();
}
private void OnTimedEvent(Object source, System.Timers.ElapsedEventArgs e)
{
if (useExpireFlag)
{
are.Set();
}
setTimer.Stop();
setTimer.Enabled = false;
}
public void BeginRequest(RequestData data, HttpAsyncCallback callback, object state)
{
var request = WebRequest.CreateHttp(data.Request.Url);
request.Method = data.Request.Method;
//data.Request.BodySize;
//data.Request.Comment;
//data.Request.Cookies;
//data.Request.Headers;
//data.Request.HeadersSize;
//data.Request.HttpVersion;
//data.Request.PostData;
//data.Request.QueryString;
var gate = new AutoResetEvent(false);
if (!string.IsNullOrEmpty(data.Request.PostData.Text))
{
request.BeginGetRequestStream(ar =>
{
var postStream = request.EndGetRequestStream(ar);
byte[] byteArray = Encoding.UTF8.GetBytes(data.Request.PostData.Text);
postStream.Write(byteArray, 0, byteArray.Length);
postStream.Flush();
gate.Set();
}, state);
}
else
{
gate.Set();
}
gate.WaitOne();
var result = request.BeginGetResponse(ar =>
{
var r = request.EndGetResponse(ar);
var s = r.GetResponseStream();
var d = ReadFully(s);
var txt = Encoding.UTF8.GetString(d, 0, d.Length);
data.Response = new Response()
{
Content = new Content()
{
Text = txt
}
};
gate.Set();
}, state);
gate.WaitOne();
}
static void Main(string[] args)
{
AutoResetEvent syncEvent = new AutoResetEvent(false);
AutoResetEvent idleEvent = new AutoResetEvent(false);
Dictionary<string, object> input = new Dictionary<string, object> { { "MaxNumber", 100 } };
WorkflowApplication app = new WorkflowApplication(new SequentialNumberGuessWorkflow(), input);
app.Completed = delegate(WorkflowApplicationCompletedEventArgs e)
{
int Turns = Convert.ToInt32(e.Outputs["Turns"]);
Console.WriteLine("Congratulations, you guessed the number in {0} turns", Turns);
syncEvent.Set();
};
app.Aborted = delegate(WorkflowApplicationAbortedEventArgs e)
{
Console.WriteLine(e.Reason);
syncEvent.Set();
};
app.OnUnhandledException = delegate(WorkflowApplicationUnhandledExceptionEventArgs e)
{
Console.WriteLine(e.UnhandledException.ToString());
syncEvent.Set();
return UnhandledExceptionAction.Abort;
};
app.Idle = delegate(WorkflowApplicationIdleEventArgs e)
{
idleEvent.Set();
};
app.Run();
// Loop until the workflow completes.
WaitHandle[] handles = new WaitHandle[] { syncEvent, idleEvent };
while (WaitHandle.WaitAny(handles) != 0)
{
// Gather the user input and resume the bookmark.
bool validEntry = false;
while (!validEntry)
{
int Guess;
if (!Int32.TryParse(Console.ReadLine(), out Guess))
{
Console.WriteLine("Please enter an integer.");
}
else
{
validEntry = true;
app.ResumeBookmark("EnterGuess", Guess);
}
}
}
}
private static void onCancel()
{
OpenRPA.Input.InputDriver.Instance.OnMouseDown -= onMouseDown;
OpenRPA.Input.InputDriver.Instance.OnMouseUp -= onMouseUp2;
OpenRPA.Input.InputDriver.Instance.OnMouseMove -= onMouseMove;
OpenRPA.Input.InputDriver.Instance.onCancel -= onCancel;
OpenRPA.Input.InputDriver.Instance.CallNext = true;
point = System.Drawing.Point.Empty;
removeform();
waitHandle.Set();
}
//public static System.Drawing.Point GetClick()
//{
// createform();
// OpenRPA.Input.InputDriver.Instance.OnMouseDown += onMouseDown;
// OpenRPA.Input.InputDriver.Instance.OnMouseUp += onMouseUp2;
// OpenRPA.Input.InputDriver.Instance.OnKeyUp += OnKeyUp;
// waitHandle = new System.Threading.AutoResetEvent(false);
// waitHandle.WaitOne();
// return point;
//}
private static void OnKeyUp(Input.InputEventArgs e)
{
if (e.Key == Input.KeyboardKey.ESCAPE || e.Key == Input.KeyboardKey.ESC)
{
OpenRPA.Input.InputDriver.Instance.OnMouseDown -= onMouseDown;
OpenRPA.Input.InputDriver.Instance.OnMouseUp -= onMouseUp2;
OpenRPA.Input.InputDriver.Instance.OnKeyUp -= OnKeyUp;
OpenRPA.Input.InputDriver.Instance.OnMouseMove -= onMouseMove;
point = System.Drawing.Point.Empty;
removeform();
waitHandle.Set();
}
}
/// <summary>
/// Queries all privileges assigned to this universe.
/// </summary>
/// <returns>An enumerator returning KeyValuePairs of Account and Privileges. The entry can be orphaned, when the corresponding Account is null.</returns>
public IEnumerable <KeyValuePair <Account, Privileges> > QueryPrivileges()
{
using (System.Threading.AutoResetEvent are = new System.Threading.AutoResetEvent(false))
{
List <KeyValuePair <uint, Privileges> > ids = new List <KeyValuePair <uint, Privileges> >();
using (Session session = Server.connection.NewSession())
{
Packet packet = session.Request;
packet.Command = 0x44;
packet.BaseAddress = ID;
Server.connection.Send(packet);
Server.connection.Flush();
ThreadPool.QueueUserWorkItem(async delegate {
// I hate you for forcing me to do this, microsoft. Really.
packet = await session.Wait().ConfigureAwait(false);
are.Set();
});
are.WaitOne();
BinaryMemoryReader reader = packet.Read();
while (reader.Size > 0)
{
ids.Add(new KeyValuePair <uint, Privileges>(reader.ReadUInt32(), (Privileges)reader.ReadByte()));
}
}
Account account = null;
foreach (KeyValuePair <uint, Privileges> kvp in ids)
{
ThreadPool.QueueUserWorkItem(async delegate {
// I hate you for forcing me to do this, microsoft. Really.
account = (await Server.QueryAccount(kvp.Key).ConfigureAwait(false)) ?? new Account(Server, kvp.Key);
are.Set();
});
are.WaitOne();
yield return(new KeyValuePair <Account, Privileges>(account, kvp.Value));
}
}
}
private void CmdHandle(EquCYGCmd input)
{
Task task = new Task((state) =>
{
EquCYGCmd pCYGCmd = state as EquCYGCmd;
OutputRunInfo(rtxtOutput, "处理命令，命令代码：" + pCYGCmd.CmdCode + " 编码：" + pCYGCmd.SampleCode);
Thread.Sleep(5000);
pCYGCmd.ResultCode = 1;
pCYGCmd.FinishTime = DateTime.Now;
pCYGCmd.DataFlag = 1;
this.EquDber.Update(pCYGCmd);
OutputRunInfo(rtxtOutput, "取样成功,编码：" + pCYGCmd.SampleCode);
EquCYGSample equcygsample = this.EquDber.Entity <EquCYGSample>(" where SampleCode='" + pCYGCmd.SampleCode + "'");
if (equcygsample != null)
{
equcygsample.SampleCode = "";
equcygsample.DataFlag = 0;
this.EquDber.Update(equcygsample);
}
OutputRunInfo(rtxtOutput, "清理样柜成功,编码：" + pCYGCmd.SampleCode);
autoResetEvent.Set();
}, input);
task.Start();
}
private static void Main(string[] args)
{
var taskOne = Task.Factory.StartNew(() =>
{
Console.WriteLine("Task 1 is starting...");
Thread.Sleep(5000);
AutoResetEvent.Set();
Console.WriteLine("Task 1 is completed.");
});
var taskTwo = Task.Factory.StartNew(() =>
{
Console.WriteLine("Task 2 waiting for Task 1 to complete...");
AutoResetEvent.WaitOne();
Console.WriteLine("Task 2 is started...");
Console.WriteLine("Waiting for AutoResetEvent to set...");
AutoResetEvent.WaitOne();
});
taskTwo.Wait(); // taskTwo will never complete as its waiting for autoResetEvent to set, but no thread is executing and setting it.
Console.ReadLine();
}
private void InterruptHendler(SimulatorEvents Interrupt, int info)
{
if (Interrupt == SimulatorEvents.CLOCK_INTERRUPT)
{
if (info == VAX11Simulator.Console.INIT_CLOCK)
{
InitClockInterrupt();
}
else if (info == VAX11Simulator.Console.ABORT_CLOCK)
{
AbortClockInterrupt();
}
else
{
throw new PanicException();
}
}
else if (Interrupt == SimulatorEvents.POWER_DOWN_INTERRUPT)
{
//if we want to send event do it here.
bConsoleClosed = true;
BreakPointWait.Set();
if (bInDebug && info == 1)
{
_theMainApplication.Invoke(new ProgramEndHandler(_theMainApplication.InterfaceDoRestartDebuggedProgram), new object[] { "Program ended because Console has been closed" });
}
}
else
{
theSimulator.SendEvent(Interrupt, info);
}
}
FacetedMesh MeshPrim(Primitive prim)
{
FacetedMesh mesh = null;
if (prim.Sculpt == null || prim.Sculpt.SculptTexture == UUID.Zero)
{
mesh = Mesher.GenerateFacetedMesh(prim, DetailLevel.Highest);
}
else if (prim.Sculpt.Type != SculptType.Mesh)
{
Image img = null;
if (LoadTexture(prim.Sculpt.SculptTexture, ref img, true))
{
mesh = Mesher.GenerateFacetedSculptMesh(prim, (Bitmap)img, DetailLevel.Highest);
}
}
else
{
var gotMesh = new System.Threading.AutoResetEvent(false);
Client.Assets.RequestMesh(prim.Sculpt.SculptTexture, (success, meshAsset) =>
{
if (!success || !FacetedMesh.TryDecodeFromAsset(prim, meshAsset, DetailLevel.Highest, out mesh))
{
Logger.Log("Failed to fetch or decode the mesh asset", Helpers.LogLevel.Warning, Client);
}
gotMesh.Set();
});
gotMesh.WaitOne(20 * 1000, false);
}
return(mesh);
}
public static void Main(string[] args)
{
var timeout = Int32.Parse(args[0]);
var waitEvent = new System.Threading.AutoResetEvent(false);
var hr = new HandlerRoutine(type =>
{
Console.WriteLine($"ConsoleCtrlHandler got signal: {type}");
Console.WriteLine("Waiting for shutdown.");
for (int countdown = 1; countdown <= timeout; countdown++)
{
Console.WriteLine($"{countdown}");
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(1));
}
Console.WriteLine("Done waiting - setting event and exiting.");
waitEvent.Set();
return(false);
});
SetConsoleCtrlHandler(hr, true);
Console.WriteLine("Shutdown will wait {0} seconds.", timeout);
Console.WriteLine("Waiting on handler to trigger");
waitEvent.WaitOne();
GC.KeepAlive(hr);
}
public TcpNotifyServer()
{
queue.callback = () =>
{
ARE.Set();
};
}
public void AutoRestEventTest()
{
CodeTimer.Time("AutoResetEvent(false)", () =>//无信号,可以通过WaitOne 阻塞线程的执行,通过Set发出信号唤醒等待的线程
{
using (System.Threading.AutoResetEvent are = new System.Threading.AutoResetEvent(false))
{
System.Threading.ThreadPool.QueueUserWorkItem((s) =>
{
Thread.Sleep(1000);
Console.WriteLine("Run!");
are.Set();
});
are.WaitOne();
}
});
CodeTimer.Time("AutoResetEvent(true)", () =>//有信号表示终止状态，即线程属于闲置状态
{
using (System.Threading.AutoResetEvent are = new System.Threading.AutoResetEvent(true))
{
System.Threading.ThreadPool.QueueUserWorkItem((s) =>
{
Thread.Sleep(1000);
Console.WriteLine("Not Run!");
are.Set();
});
are.WaitOne();//不会等待子线程的结束
}
});
}
public async Task TestMICRenderURLScopeID()
{
// Arrange
var builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret);
var client = builder.Build();
var autoEvent = new System.Threading.AutoResetEvent(false);
string urlToTestForScopeID = String.Empty;
var micDelegate = new KinveyMICDelegate <User>()
{
onError = (user) => { },
onSuccess = (error) => { },
onReadyToRender = (url) => {
urlToTestForScopeID = url;
autoEvent.Set();
}
};
// Act
User.LoginWithMIC("mytestredirectURI", micDelegate);
bool signal = autoEvent.WaitOne(5000);
// Assert
Assert.IsTrue(signal);
Assert.IsFalse(urlToTestForScopeID.Equals(string.Empty));
Assert.IsTrue(urlToTestForScopeID.Contains("scope=openid"));
}
public object SendEvent(int events, object param)
{
if (threadid == MT.Thread.CurrentThread.ManagedThreadId)
{
bool success = true;
while (success)
{
DoEvent(ref success);
}
return(OnProc(events, param));
}
else
{
using (MT.AutoResetEvent signal = new MT.AutoResetEvent(false))
{
object result = null;
PostEvent(events, param, (response) =>
{
result = response;
signal.Set();
});
while (!signal.WaitOne(1))
{
;
}
return(result);
}
}
}
private void ProcessQueue(object sender, Timers.ElapsedEventArgs e)
{
while (messageQueue.Count != 0)
{
var msg = (Datagram)null;
if (!messageQueue.TryPeek(out msg))
{
continue;
}
if (msg != null && (running || msg.Sticky))
{
msg.Send();
if (msg.SendCount > DATAGRAMS_PER_MESSAGE)
{
messageQueue.TryDequeue(out msg);
}
break;
}
else
{
messageQueue.TryDequeue(out msg);
}
}
datagramPosted.Set();
queueTimer.Enabled = messageQueue.Count != 0;
queueTimer.Interval = random.Next(25, running ? 75 : 50);
}
private async Task ExecCommandRun(RoutedEventArgs e)
{
if (ActiveDocument != null)
{
if (IsPaused)
{
ActiveDocument.RemoveExecutingMarker();
IsPaused = false;
m_BreakPointLock.Set();
}
else
{
IsBuilding = true;
UpdateLayout();
var fileName = ActiveDocument.DocumentFileName;
await Task.Run(delegate
{
var bSucComp = m_VM.compilestatic(new string[] { fileName }, "test", true);
m_VM.pushroottable();
var bSucCall = m_VM.call(1, false, true);
});
IsBuilding = false;
}
UpdateLayout();
}
}
internal void Trigger()
{
while (isReadyForEvent == false)
{
System.Threading.Thread.Sleep(0);
}
auto_event.Set();
}
private void RequestWait()
{
if (waiting)
{
throw new InternalError();
}
Report.Debug(DebugFlags.Wait, "Signalling wait event");
wait_event.Set();
}
public void Shutdown(object owner, bool continueExistingPeriodicTasks, bool executeExistingDelayedTasks)
{
if (!executeExistingDelayedTasks)
{
lock (tasks) {
for (int n = 0; n < tasks.Count; n++)
{
IScheduledITask t = tasks [n];
if (t.Owner == owner)
{
tasks.RemoveAt(n);
n--;
}
}
newTask.Set();
}
}
}
protected override void Dispose(bool disposing)
{
if (!disposed)
{
disposed = true;
GameInstance.Components.Remove(this);
if (ownsServices)
{
GameInstance.Components.Remove(services);
services.Dispose();
}
todo.Set();
thread.Join();
todo.Close();
thread = null;
todo = null;
}
}
/// <summary>
/// Clean up any resources being used. and stop events
/// </summary>
protected override void Dispose(bool disposing)
{
if (bNowExiting)
{
eWaitForInput.Set();
}
if (bTextMode)
{
caretThread.Abort();
}
if (disposing)
{
if (components != null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}
private void download_completed(object sender)
{
lock (locker)
{
download_file current = (download_file)sender;
Console.SetCursorPosition(0, current.ConsoleLine);
Console.ForegroundColor = ConsoleColor.Gray;
Console.ForegroundColor = current.Error == null ? ConsoleColor.DarkGreen : ConsoleColor.DarkRed;
Console.WriteLine(
string.Format("{0,5} -> {4,14}{3,8} {1,-30} {2,-30}",
getIcon(current.Status),
current.FileName,
current.Error == null ? "" : string.Format("Error: {0}", current.Error.Message),
ContentSizeToStr(current.ContentBytes),
string.Empty
)
.PadRight(Console.WindowWidth - 1));
Console.ResetColor();
total_bytes += current.ContentBytes;
if (current.Error != null)
{
ErrorList += string.Format("{0,5}File: {1}\n{0,5}Error message: {2}\n\n",
" ",
current.FileName,
current.Error.Message + (current.Error.InnerException != null ? ("\nInnerMessage: " + current.Error.InnerException.Message) : ""));
}
}
download_file _current = (download_file)sender;
//check to finish
if (started_count == files.Count() &&
downloader.Where(x => x.Status == DownloadFileStatus.SUCCESS ||
x.Status == DownloadFileStatus.ERROR).Count() == parallel_count)
{
Console.SetCursorPosition(0, downloader.Max(x => x.ConsoleLine) + 2);
Console.ResetColor();
Console.WriteLine(" -------------------------\n");
if (ErrorList != null)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine(ErrorList);
Console.ResetColor();
Console.WriteLine(" -------------------------");
}
resetEvent.Set();
}
else if (started_count != files.Count())
{
_current.download(files[started_count], process_line_start + started_count);
started_count++;
}
}
static internal void ClearAutoEvents()
{
lock (_sLockObj)
{
while (_AutoEventQueue.Count > 0)
{
System.Threading.AutoResetEvent aEvent = _AutoEventQueue.Dequeue();
aEvent.Set();
}
}
}
public void Foo(Action printFoo)
{
for (int i = 0; i < n; i++)
{
slim1.WaitOne();
// printFoo() outputs "foo". Do not change or remove this line.
printFoo();
slim2.Set();
}
}
public void UnInit()
{
try
{
at_stinterval.Set();
LogManager.WriteLog("StackerServiceHandle Thread Stoped ", LogManager.enumLogLevel.Info);
}
catch (Exception ex)
{
ExceptionManager.Publish(ex);
}
}
void CloseCamera()
{
if (_ptGreyCamera != null)
{
_ptGreyCamera.Close();
}
if (_ptGreyStopImageThreadEvent != null)
{
_ptGreyStopImageThreadEvent.Set();
}
}
static void Add(object data)
{
if (data is AddParams)
{
Console.WriteLine($"ID of thread in Add(): {Thread.CurrentThread.ManagedThreadId}");
AddParams ap = (AddParams)data;
Console.WriteLine($"{ap.a} + {ap.b} is {ap.a + ap.b}");
waitHandle.Set();
}
}
