public virtual void Send(byte[] data)
{
try
{
_SendObj.Send(data);
}
catch (ObjectDisposedException)
{
IsConn = false;
Disconnect?.Invoke("与服务器断开连接");
}
catch (SocketException)
{
try
{
wait.Dispose();
AsynEvent.Dispose();
_sock.Close();
_sock.Dispose();
}
catch { }
IsConn = false;
Disconnect?.Invoke("与服务器断开连接");
}
}
public void Should_release_the_pool()
{
// Arrange
var blockTheThread = new AutoResetEvent(false);
var countdownEvent = new CountdownEvent(1);
var queue = Substitute.For<IInMemoryPriorityQueue<GenericPriorityMessage<BasicDeliverEventArgs>>>();
queue.When(x => x.Dequeue()).Do(callInfo => { countdownEvent.Signal(); blockTheThread.WaitOne(); });
var consumer = new PriorityBurrowConsumer(Substitute.For<IModel>(), Substitute.For<IMessageHandler>(), Substitute.For<IRabbitWatcher>(), false, 1);
consumer.Init(queue, Substitute.For<CompositeSubscription>(), 1, Guid.NewGuid().ToString());
consumer.Ready();
// Action
countdownEvent.Wait();
countdownEvent.Reset();
blockTheThread.Set();
consumer.MessageHandlerHandlingComplete(null);
countdownEvent.Wait();
// Assert
queue.Received(2).Dequeue();
consumer.Dispose();
blockTheThread.Dispose();
}
public BackgroundDispatcher(string name)
{
AutoResetEvent are = new AutoResetEvent(false);
Thread thread = new Thread((ThreadStart)delegate
{
_dispatcher = Dispatcher.CurrentDispatcher;
_dispatcher.UnhandledException +=
delegate(
object sender,
DispatcherUnhandledExceptionEventArgs e)
{
e.Handled = true;
};
are.Set();
Dispatcher.Run();
});
thread.Name = string.Format("BackgroundStaDispatcher({0})", name);
thread.SetApartmentState(ApartmentState.MTA);
thread.IsBackground = true;
thread.Start();
are.WaitOne();
are.Close();
are.Dispose();
}
public void Execute()
{
exception = null;
try
{
try
{
proxy.UploadDataInternal(solution, null, checkExisting, !String.IsNullOrEmpty(contentEncoding), contentEncoding, filepath, ProgressCallback, progressStep);
proxy.CommitAsyncUploadRecord(solution, sessionGuid);
}
catch (Exception e)
{
proxy.CommitAsyncUploadRecord(solution, sessionGuid, MakeExceptionString(e));
}
}
finally
{
try
{
startedEvent.Dispose();
System.IO.File.Delete(filepath);
}
catch
{
}
}
}
public void CanCaptureAudio()
{
int n = 0;
SoundInTests((c) =>
{
for (int i = 0; i < 500; i++)
{
var waitHandle = new AutoResetEvent(true);
c.DataAvailable += (s, e) =>
{
waitHandle.Reset();
};
c.Initialize();
c.Start();
if (!waitHandle.WaitOne(2000))
Assert.Fail("Timeout");
else
{
Debug.WriteLine(n.ToString());
n++;
}
c.Stop();
waitHandle.Dispose();
}
});
}
public Task StartAsync()
{
System.Windows.Threading.Dispatcher.CurrentDispatcher.VerifyAccess();
if (ClientConfig.EmbeddedServer == EmbeddedServerMode.None)
throw new Exception();
var path = System.Environment.GetFolderPath(System.Environment.SpecialFolder.LocalApplicationData);
path = System.IO.Path.Combine(path, "Dwarrowdelf", "save");
if (!System.IO.Directory.Exists(path))
System.IO.Directory.CreateDirectory(path);
var gameDir = path;
bool cleanSaves = ClientConfig.CleanSaveDir;
Guid save = Guid.Empty;
m_saveManager = new SaveManager(gameDir);
if (cleanSaves)
m_saveManager.DeleteAll();
else
save = m_saveManager.GetLatestSaveFile();
CreateEmbeddedServer(gameDir, save);
var tcs = new TaskCompletionSource<object>();
var serverStartWaitHandle = new AutoResetEvent(false);
ThreadPool.RegisterWaitForSingleObject(serverStartWaitHandle,
(o, timeout) =>
{
serverStartWaitHandle.Dispose();
if (timeout)
{
m_serverThread.Abort();
tcs.SetException(new Exception("Timeout waiting for server"));
}
else
{
tcs.SetResult(null);
}
},
null, TimeSpan.FromSeconds(60), true);
m_serverThread = new Thread(ServerMain);
m_serverThread.Start(serverStartWaitHandle);
return tcs.Task;
}
/// <summary>
/// Close and release all resources of this channel.
/// </summary>
public void Dispose()
{
if (closing)
{
return;
}
closing = true;
reset.Set();
resetR.Set();
resetR.Dispose();
reset.Dispose();
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing && null != _thread)
{
Stop();
if (null != _triggeringEvent)
{
_triggeringEvent.Dispose();
}
_triggeringEvent = null;
_thread = null;
}
}
public Task StartAsync(EmbeddedServerOptions options)
{
if (options.ServerMode == EmbeddedServerMode.None)
throw new Exception();
m_serverMode = options.ServerMode;
m_gameOptions = options.NewGameOptions;
if (!System.IO.Directory.Exists(options.SaveGamePath))
System.IO.Directory.CreateDirectory(options.SaveGamePath);
Guid save = Guid.Empty;
m_saveManager = new SaveManager(options.SaveGamePath);
if (options.CleanSaveDir)
m_saveManager.DeleteAll();
else
save = m_saveManager.GetLatestSaveFile();
CreateEmbeddedServer(options.SaveGamePath, save);
var tcs = new TaskCompletionSource<object>();
var serverStartWaitHandle = new AutoResetEvent(false);
ThreadPool.RegisterWaitForSingleObject(serverStartWaitHandle,
(o, timeout) =>
{
serverStartWaitHandle.Dispose();
if (timeout)
{
m_serverThread.Abort();
tcs.SetException(new Exception("Timeout waiting for server"));
}
else
{
tcs.SetResult(null);
}
},
null, TimeSpan.FromSeconds(60), true);
m_serverThread = new Thread(ServerMain);
m_serverThread.Start(serverStartWaitHandle);
return tcs.Task;
}
public void StartWithCallback()
{
// arrange
var loop = new EventLoop();
var wait = new AutoResetEvent(false);
// act
loop.Start(() => wait.Set());
// assert
Assert.That(() => wait.WaitOne(100), Is.True);
// cleanup
loop.Dispose();
wait.Dispose();
}
public void Stop()
{
// stops the timer and wait for the current operation to complete
_logger.Info("Stopping Readers, waiting for remaining operations to complete...");
processQueue.CompleteAdding();
WaitHandle waitHandle = new AutoResetEvent(false);
_readTimer.Dispose(waitHandle);
waitHandle.WaitOne();
waitHandle.Dispose();
var tasks=new List<Task>();
tasks.Add(_readTask);
Task.WaitAll(tasks.ToArray());
_logger.Info("Readers stopped");
}
public void Dispose()
{
Debug("Disposing SSDP");
running = false;
while (messageQueue.Count != 0)
{
datagramPosted.WaitOne();
}
client.DropMulticastGroup(SSDP_IP);
notificationTimer.Enabled = false;
queueTimer.Enabled = false;
notificationTimer.Dispose();
queueTimer.Dispose();
datagramPosted.Dispose();
}
public void Schedule()
{
// arrange
var loop = new EventLoop();
var wait = new AutoResetEvent(false);
var counter = 0;
// act
loop.Schedule(() => counter++);
loop.Schedule(() => counter++);
loop.Start(() => wait.Set());
loop.Schedule(() => counter++);
// assert
Assert.That(() => wait.WaitOne(100), Is.True);
Assert.That(counter, Is.EqualTo(3));
// cleanup
loop.Dispose();
wait.Dispose();
}
public void Dispose()
{
Get_Reg_threaFucEvent.Dispose();
}
private void DoExportEmlItem(Item itemInEws, MemoryStream emlStream, EwsServiceArgument argument)
{
PropertySet props = new PropertySet(EmailMessageSchema.MimeContent);
//itemInEws.Load(props);
//This results in a GetItem call to EWS.
AutoResetEvent ev = new AutoResetEvent(false);
Exception ex = null;
Timer t = null;
try
{
bool hasLoad = false;
t = new Timer((arg) =>
{
try
{
if (hasLoad)
{
ex = new TimeoutException("Export eml message time out.");
ev.Set();
}
else
{
hasLoad = true;
itemInEws.Load(props);
ev.Set();
}
}
catch (Exception e)
{
ex = e;
LogFactory.LogInstance.WriteException(LogLevel.ERR, "Export eml failed", e, e.Message);
ev.Set();
}
}, null, 0, ExportUploadHelper.TimeOut);
while (!ev.WaitOne(1000))
{
}
}
finally
{
if (t != null)
t.Dispose();
if (ev != null)
ev.Dispose();
t = null;
ev = null;
}
if (ex != null)
{
throw new ApplicationException("Export eml error", ex);
}
//var email = EmailMessage.Bind(CurrentExchangeService, itemInEws.Id, props);
emlStream.Write(itemInEws.MimeContent.Content, 0, itemInEws.MimeContent.Content.Length);
itemInEws.MimeContent.Content = null;
}
void OnSettings()
{
StartupSettingsWaitHandler = new AutoResetEvent(false);
ApplicationService.BeginInvoke(() =>
{
if (StartupSettingsWaitHandler != null)
{
StartupSettingsWaitHandler.WaitOne();
StartupSettingsWaitHandler.Dispose();
}
StartupSettingsWaitHandler = null;
});
DialogService.ShowModalWindow(new StartupSettingsViewModel(_clientType));
StartupSettingsWaitHandler.Set();
}
public async Task ResetAndMoveIn()
{
_smartWindowSkin.DisableWindow();
_advancedWindowSkin.DisableWindow();
bool isadvancedwindow = HostedWindow != _smartWindowSkin;
_smartWindowSkin = new WindowSmartView();
_advancedWindowSkin = new WindowAdvancedView();
ApplyHostWindow(isadvancedwindow ? _advancedWindowSkin : _smartWindowSkin, false);
var outanimation = new ThicknessAnimation(new Thickness(-100, 0, 100, 0), new Thickness(0), TimeSpan.FromMilliseconds(350));
var fadeanimation = new DoubleAnimation(0, 1, TimeSpan.FromMilliseconds(400));
var control = (DependencyObject)HostedWindow;
Storyboard.SetTarget(outanimation, control);
Storyboard.SetTarget(fadeanimation, control);
Storyboard.SetTargetProperty(outanimation, new PropertyPath(MarginProperty));
Storyboard.SetTargetProperty(fadeanimation, new PropertyPath(OpacityProperty));
var story = new Storyboard();
story.Children.Add(outanimation);
story.Children.Add(fadeanimation);
var handler = new AutoResetEvent(false);
story.Completed += (s, e) => handler.Set();
story.Begin(this);
await Task.Run(() => handler.WaitOne());
handler.Dispose();
ResetFlyout();
}
public void Stop()
{
// If we're not running, then this is moot. Bail.
if (m_refreshtimer == null)
{
return;
}
// Setup an event to handle waiting for our cleanup.
AutoResetEvent cleanup = new AutoResetEvent(false);
// Ask the timer to clean up.
m_refreshtimer.Dispose(cleanup);
// If the timer goes the larger of two extra cycles or 100ms and still hasn't stopped
if (!cleanup.WaitOne(Math.Min(2 * m_period,100)))
{
// Die.
throw new TimeoutException("Timer failed to stop.");
}
// cleanup our timer handle
m_refreshtimer = null;
// dispose our wait handle
cleanup.Dispose();
// Lastly, if the serial port is open (it should be.)
if (m_targetport.IsOpen) {
// Close it.
m_targetport.Close();
}
}
private void WaitForDeploymentComplete(string requestToken)
{
AutoResetEvent threadBlocker = null;
try
{
threadBlocker = new AutoResetEvent(false);
deployAppWaitTimer = new System.Timers.Timer(5000);
deployAppWaitTimer.Elapsed += new ElapsedEventHandler(
delegate(object sender, ElapsedEventArgs e)
{
string requestUri;
string responseXml;
bool isError;
HttpWebRequest webRequest;
HttpWebResponse webResponse = null;
X509Certificate2 authCert;
try
{
Console.WriteLine("Getting deployment request status.");
deployAppWaitTimer.Stop();
authCert = GetAuthCertificate(certThumbprint);
requestUri = string.Format("https://management.core.windows.net/{0}/operations/{1}", subscriptionId, requestToken);
webRequest = (HttpWebRequest)WebRequest.Create(requestUri);
webRequest.Method = "GET";
webRequest.ClientCertificates.Add(authCert);
webRequest.Headers.Add("x-ms-version", "2009-10-01");
webResponse = (HttpWebResponse)webRequest.GetResponse();
if (webResponse.StatusCode != HttpStatusCode.OK)
{
throw new Exception(@"Error fetching status code for creating deployment. Error code - " +
webResponse.StatusCode.ToString() +
" Description - " + webResponse.StatusDescription);
}
using (Stream responseStream = webResponse.GetResponseStream())
using (StreamReader responseStreamReader = new StreamReader(responseStream))
{
responseXml = responseStreamReader.ReadToEnd();
if (IsDeploymentComplete(responseXml, out isError) == true)
{
Console.WriteLine("Deployment successfull.");
deployAppWaitTimer.Dispose();
threadBlocker.Set();
}
else if (isError == true) //Give up.
{
deployAppWaitTimer.Dispose();
threadBlocker.Set();
}
else
{
Console.WriteLine("Deployment not complete yet. System shall retry after 5 seconds.");
deployAppWaitTimer.Start();
}
}
}
finally
{
if (webResponse != null) webResponse.Close();
}
});
deployAppWaitTimer.Start();
threadBlocker.WaitOne();
}
finally
{
if (threadBlocker != null) threadBlocker.Dispose();
}
}
public async Task Lock(string path, Func<Task> action) {
using (var autoResetEvent = new AutoResetEvent(false)) {
try {
using (var fileSystemWatcher =
new FileSystemWatcher(Path.GetDirectoryName(path)) {
EnableRaisingEvents = true
}) {
fileSystemWatcher.Deleted +=
(o, e) => {
if (Path.GetFullPath(e.FullPath) == Path.GetFullPath(path))
autoResetEvent.Set();
};
while (true) {
try {
using (var file = File.Open(path,
FileMode.OpenOrCreate,
FileAccess.ReadWrite,
FileShare.None)) {
fileSystemWatcher.Dispose();
autoResetEvent.Dispose();
await action().ConfigureAwait(false);
break;
}
} catch (IOException) {
autoResetEvent.WaitOne();
autoResetEvent.Reset();
}
}
}
} finally {
File.Delete(path);
}
}
}
public override void DoAction(Action action)
{
//LogFactory.LogInstance.WriteLog(LogInterface.LogLevel.DEBUG, GetMessage("Enter timeout operator."));
AutoResetEvent ev = null;
Exception exception = null;
try
{
ev = new AutoResetEvent(false);
ThreadPool.QueueUserWorkItem((args) =>
{
try
{
base.DoAction(action);
}
catch (Exception ex)
{
exception = ex;
}
if (ev != null)
ev.Set();
}, null);
if (!ev.WaitOne(TimeOut))
{
exception = new TimeoutException();
LogFactory.LogInstance.WriteException(LogInterface.LogLevel.ERR, GetMessage("time out"), exception, "time out");
}
}
finally
{
//LogFactory.LogInstance.WriteLog(LogInterface.LogLevel.DEBUG, GetMessage("Exit timeout operator."));
if (ev != null)
{
ev.Dispose();
ev = null;
}
}
if (exception != null)
{
LogFactory.LogInstance.WriteException(LogInterface.LogLevel.ERR, GetMessage("throw exception in timeout operator"), exception, exception.Message);
throw exception;
}
}
/// <exception cref="OutOfMemoryException">Failed to allocate the event object</exception>
/// <exception cref="SystemException">Failed to create the system event due to some system error</exception>
private AutoResetEvent GetOrCreateWriterEvent()
{
AutoResetEvent currentEvent = _writerEvent;
if (currentEvent != null)
{
return currentEvent;
}
currentEvent = new AutoResetEvent(false);
AutoResetEvent previousEvent = Interlocked.CompareExchange(ref _writerEvent, currentEvent, null);
if (previousEvent == null)
{
return currentEvent;
}
currentEvent.Dispose();
return previousEvent;
}
/// <summary>
/// Wait for the operation to complete and throw the exception if any.
/// </summary>
internal void EndInvoke()
{
_invokeOnThreadEvent = new AutoResetEvent(false);
// Start the thread wait loop.
WaitHandle[] waitHandles = new WaitHandle[2] { AsyncWaitHandle, _invokeOnThreadEvent };
bool waiting = true;
while (waiting)
{
int waitIndex = WaitHandle.WaitAny(waitHandles);
if (waitIndex == 0)
{
waiting = false;
}
else
{
// Invoke callback on thread.
try
{
_invokeCallback(_invokeCallbackState);
}
catch (Exception e)
{
CommandProcessorBase.CheckForSevereException(e);
}
}
}
AsyncWaitHandle.Dispose();
_completedWaitHandle = null; // Allow early GC
_invokeOnThreadEvent.Dispose();
_invokeOnThreadEvent = null; // Allow early GC
// Operation is done: if an exception occured, throw it
if (null != Exception)
{
throw Exception;
}
}
public void Run(PsoParameters psoParameters, IParticle[] proxyParticleServices = null)
{
_function = FunctionFactory.GetFitnessFunction(psoParameters.FunctionParameters);
var useGpu = psoParameters.GpuParameters.UseGpu && GpuController.AnySupportedGpu();
CudaParticle cudaParticle = null;
if (useGpu)
cudaParticle = PrepareCudaAlgorithm(psoParameters);
var particles = PrepareParticles(psoParameters,proxyParticleServices,cudaParticle);
RunningParameters = psoParameters;
_algorithm = new PsoAlgorithm(psoParameters, _function, particles.ToArray());
_cudaReadyLock = new AutoResetEvent(false);
if (useGpu)
RunningCudaAlgorithm = Task<ParticleState>.Factory.StartNew(() =>
{
_cudaAlgorithm.Initialize();
_cudaReadyLock.Set();
var result = _cudaAlgorithm.Run(_cudaTokenSource.Token);
_function.Evaluate(result.Location);
_cudaAlgorithm.Dispose();
return result;
}, _cudaTokenSource.Token);
else
_cudaReadyLock.Set();
RunningAlgorithm = Task<ParticleState>.Factory.StartNew(delegate
{
_cudaReadyLock.WaitOne();
_cudaReadyLock.Dispose();
return StartAlgorithm(_tokenSource.Token);
}, _tokenSource.Token);
}
public void Dispose()
{
_endEvent.Set();
_endedEvent = new AutoResetEvent(false);
Debug.WriteLine("Manager Dispose");
_endedEvent.WaitOne();
_endedEvent.Dispose();
_endedEvent = null;
DoDispose();
Debug.WriteLine("Manager Disposed");
Trace.Flush();
}
public async Task DisconnectAsync(IProgress<string> prog)
{
if (m_user == null)
return;
m_disconnectEvent = new AutoResetEvent(false);
prog.Report("Saving");
m_user.SaveEvent += OnGameSaved;
m_user.Send(new SaveRequestMessage());
await Task.Run(() => m_disconnectEvent.WaitOne());
m_user.SaveEvent -= OnGameSaved;
prog.Report("Logging Out");
m_user.SendLogOut();
await Task.Run(() => m_disconnectEvent.WaitOne());
m_disconnectEvent.Dispose();
m_disconnectEvent = null;
}
/// <summary>
/// Creates a new worker thread and adds it to the pool.
/// </summary>
/// <remarks>
/// The new thread has a ref count of 0.
/// </remarks>
/// <returns>
/// The dispatcher associated with the new worker thread.
/// </returns>
private static Dispatcher AddNewThreadToPool()
{
Debug.Assert(_numThreads < _maxThreads, "Creating a thread would exceed the maximum allowed!");
AutoResetEvent isRunning = new AutoResetEvent(false);
int threadId = _threadIdCounter++;
// Spin up our worker thread. The important aspects of this
// thread are:
// 1) It runs a WPF Dispatcher loop, which is a message pump.
// 2) It is marked as STA.
// 3) It is marked as a background thread, which will allow the
// app to exit even with active UIThreadPool threads.
Thread thread = new Thread(new ParameterizedThreadStart(WorkerThreadMain));
thread.Name = "UIThreadPoolThread #" + threadId;
thread.SetApartmentState(ApartmentState.STA);
thread.IsBackground = true;
thread.Start(isRunning);
// Wait for the worker thread to get started.
isRunning.WaitOne();
isRunning.Dispose();
// Add the dispatcher to the list of free worker threads,
Dispatcher dispatcher = Dispatcher.FromThread(thread);
_poolThreads.Add(dispatcher, new Tuple<bool, int>(true, 0));
_numThreads++;
return dispatcher;
}
public async Task MoveOut()
{
var fadeanimation = new DoubleAnimation(1, 0, TimeSpan.FromMilliseconds(200));
var control = (DependencyObject)HostedWindow;
Storyboard.SetTarget(fadeanimation, control);
Storyboard.SetTargetProperty(fadeanimation, new PropertyPath(OpacityProperty));
var story = new Storyboard();
story.Children.Add(fadeanimation);
var handler = new AutoResetEvent(false);
story.Completed += (s, e) => handler.Set();
story.Begin(this);
await Task.Run(() => handler.WaitOne());
handler.Dispose();
}
async Task DisconnectAsyncInt()
{
App.MainWindow.MapControl.Environment = null;
var player = GameData.Data.User;
if (player == null)
return;
m_disconnectEvent = new AutoResetEvent(false);
SetLogOnText("Saving", 0);
ClientSaveManager.SaveEvent += OnGameSaved;
GameData.Data.User.Send(new SaveRequestMessage());
await Task.Run(() => m_disconnectEvent.WaitOne());
ClientSaveManager.SaveEvent -= OnGameSaved;
SetLogOnText("Logging Out", 0);
GameData.Data.User.SendLogOut();
await Task.Run(() => m_disconnectEvent.WaitOne());
m_disconnectEvent.Dispose();
m_disconnectEvent = null;
player.DisconnectEvent -= OnDisconnected;
CloseLoginDialog();
}
private void DownloadFileGroupBlocking(string fileGroup, Action<int> progressCallback)
{
AutoResetEvent are = new AutoResetEvent(false);
DownloadFileGroupCompletedEventHandler completedHandler = null;
DeploymentProgressChangedEventHandler progressChangedHandler = null;
completedHandler = (s, e) =>
{
ApplicationDeployment.CurrentDeployment.DownloadFileGroupCompleted -= completedHandler;
ApplicationDeployment.CurrentDeployment.DownloadFileGroupProgressChanged -= progressChangedHandler;
are.Set();
are.Dispose();
};
progressChangedHandler = (object s, DeploymentProgressChangedEventArgs e) =>
{
progressCallback(e.ProgressPercentage);
};
ApplicationDeployment.CurrentDeployment.DownloadFileGroupCompleted += completedHandler;
ApplicationDeployment.CurrentDeployment.DownloadFileGroupProgressChanged += progressChangedHandler;
ApplicationDeployment.CurrentDeployment.DownloadFileGroupAsync(fileGroup);
are.WaitOne();
}
