public void WorkerProcessMain(string argument, string passwordBase64) { int port = int.Parse(argument, CultureInfo.InvariantCulture); client = new TcpClient(); client.Connect(new IPEndPoint(IPAddress.Loopback, port)); Stream stream = client.GetStream(); receiver = new PacketReceiver(); sender = new PacketSender(stream); shutdownEvent = new ManualResetEvent(false); receiver.ConnectionLost += OnConnectionLost; receiver.PacketReceived += OnPacketReceived; sender.WriteFailed += OnConnectionLost; // send password sender.Send(Convert.FromBase64String(passwordBase64)); receiver.StartReceive(stream); while (!shutdownEvent.WaitOne(SendKeepAliveInterval, false)) { Program.Log("Sending keep-alive packet"); sender.Send(new byte[0]); } Program.Log("Closing client (end of WorkerProcessMain)"); client.Close(); shutdownEvent.Close(); }
/// <summary> /// Marks message as deleted. /// </summary> /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this method is accessed.</exception> /// <exception cref="POP3_ClientException">Is raised when POP3 serveer returns error.</exception> public void MarkForDeletion() { if(this.IsDisposed){ throw new ObjectDisposedException(this.GetType().Name); } if(this.IsMarkedForDeletion){ return; } using(MarkForDeletionAsyncOP op = new MarkForDeletionAsyncOP()){ using(ManualResetEvent wait = new ManualResetEvent(false)){ op.CompletedAsync += delegate(object s1,EventArgs<MarkForDeletionAsyncOP> e1){ wait.Set(); }; if(!this.MarkForDeletionAsync(op)){ wait.Set(); } wait.WaitOne(); wait.Close(); if(op.Error != null){ throw op.Error; } } } }
/// <summary> /// Wait Event State to Set /// </summary> public void Wait() { if(IsDebugEnabled) log.Debug("Wait event state to SET..."); var spinWait = new System.Threading.SpinWait(); var spinCount = 0; while(_state == UN_SET) { if(spinCount++ < SpinCount) { spinWait.SpinOnce(); if(_eventObj == null) { var mre = new ManualResetEvent(_state == SET); if(Interlocked.CompareExchange(ref _eventObj, mre, null) != null) { // If someone set the flag before seeing the new event object, we must ensure it's been set. if(_state == SET) _eventObj.Set(); // Lost the race w/ another thread. Just use its event. else mre.Close(); } if(_eventObj != null) _eventObj.WaitOne(); } } } }
public void Dispose() { WaitHandle notifyObject = new ManualResetEvent(false); _superLayerHideTimer.Dispose(notifyObject); notifyObject.WaitOne(); notifyObject.Close(); }
public void EventLoggerLogErrorException() { ManualResetEvent handle = new ManualResetEvent(false); try { EventLogger logger = new EventLogger(); Exception ex = new Exception(); logger.Log += (sender, args) => { Assert.AreEqual(EventLoggerEventType.Error, args.EventType); Assert.AreEqual(string.Empty, args.Message); Assert.AreEqual(ex, args.Exception); handle.Set(); }; logger.Error(ex); WaitHandle.WaitAll(new WaitHandle[] { handle }); } finally { handle.Close(); } }
public void Run() { Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); CheckToSeeIfWinServiceRunning(); try { _log.Debug("Starting up as a console application"); _exit = new ManualResetEvent(false); Console.CancelKeyPress += HandleCancelKeyPress; _coordinator.Start(); //user code starts _log.InfoFormat("[Topshelf] Running, press Control+C to exit."); _exit.WaitOne(); } catch (Exception ex) { _log.Error("An exception occurred", ex); } finally { ShutdownCoordinator(); } _exit.Close(); _exit = null; }
public void Can_send_a_message_to_initiate_a_saga_and_retreive_the_saga_instance_from_the_saga_repository() { _wait = new ManualResetEvent(false); using (var bus = _container.Resolve<IMessageBus>()) { bus.Start(); bus.Publish(new TestSagaMessage1()); _wait.WaitOne(TimeSpan.FromSeconds(5)); Assert.Equal(typeof(TestSagaMessage1), _received_message.GetType()); // create the persister from generic instance and resolve from container: var persisterType = _container.Resolve<IReflection>() .GetGenericVersionOf(typeof(ISagaPersister<>), typeof(LocalSaga)); Assert.NotNull(persisterType); var persister = _container.Resolve(persisterType) as ISagaPersister<LocalSaga>; Assert.NotNull(persister); Assert.NotEqual(Guid.Empty, _saga_id); var saga = persister.Find(_saga_id); Assert.NotNull(saga); } _wait.Close(); }
public void BootstrapsBasicApplicationFileChange() { string path = ApplicationUtils.CreateValidExampleApplication(); string filePath = Path.Combine(path, Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".dll"); ManualResetEvent handle = new ManualResetEvent(false); try { using (Bootstraps bootstraps = new Bootstraps(path, null, 500)) { bootstraps.ApplicationFilesChanged += (sender, e) => { Assert.AreEqual(filePath, e.FullPath); handle.Set(); }; Assert.AreEqual(BootstrapsPullupResultType.Success, bootstraps.PullUp().ResultType); using (File.Create(filePath)) { } WaitHandle.WaitAll(new WaitHandle[] { handle }); } } finally { handle.Close(); } }
public void AcceptAsyncShouldUseAcceptSocketFromEventArgs() { var readyEvent = new ManualResetEvent(false); var mainEvent = new ManualResetEvent(false); var listenSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); var serverSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Socket acceptedSocket = null; Exception ex = null; ThreadPool.QueueUserWorkItem(_ => { SocketAsyncEventArgs asyncEventArgs; try { listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, 0)); listenSocket.Listen(1); asyncEventArgs = new SocketAsyncEventArgs {AcceptSocket = serverSocket}; asyncEventArgs.Completed += (s, e) => { acceptedSocket = e.AcceptSocket; mainEvent.Set(); }; } catch (Exception e) { ex = e; return; } finally { readyEvent.Set(); } try { if (listenSocket.AcceptAsync(asyncEventArgs)) return; acceptedSocket = asyncEventArgs.AcceptSocket; mainEvent.Set(); } catch (Exception e) { ex = e; } }); Assert.IsTrue(readyEvent.WaitOne(1500)); if (ex != null) throw ex; var clientSocket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); clientSocket.Connect(listenSocket.LocalEndPoint); clientSocket.NoDelay = true; Assert.IsTrue(mainEvent.WaitOne(1500)); Assert.AreEqual(serverSocket, acceptedSocket, "x"); mainEvent.Reset(); if (acceptedSocket != null) acceptedSocket.Close(); listenSocket.Close(); readyEvent.Close(); mainEvent.Close(); }
internal static bool UsbIOSync(SafeHandle dev, int code, Object inBuffer, int inSize, IntPtr outBuffer, int outSize, out int ret) { SafeOverlapped deviceIoOverlapped = new SafeOverlapped(); ManualResetEvent hEvent = new ManualResetEvent(false); deviceIoOverlapped.ClearAndSetEvent(hEvent.SafeWaitHandle.DangerousGetHandle()); ret = 0; if (!Kernel32.DeviceIoControlAsObject(dev, code, inBuffer, inSize, outBuffer, outSize, ref ret, deviceIoOverlapped.GlobalOverlapped)) { int iError = Marshal.GetLastWin32Error(); if (iError != ERROR_IO_PENDING) { // Don't log errors for these control codes. do { if (code == LibUsbIoCtl.GET_REG_PROPERTY) break; if (code == LibUsbIoCtl.GET_CUSTOM_REG_PROPERTY) break; UsbError.Error(ErrorCode.Win32Error, iError, String.Format("DeviceIoControl code {0:X8} failed:{1}", code, Kernel32.FormatSystemMessage(iError)), typeof(LibUsbDriverIO)); } while (false); hEvent.Close(); return false; } } if (Kernel32.GetOverlappedResult(dev, deviceIoOverlapped.GlobalOverlapped, out ret, true)) { hEvent.Close(); return true; } UsbError.Error(ErrorCode.Win32Error, Marshal.GetLastWin32Error(), "GetOverlappedResult failed.\nIoCtlCode:" + code, typeof(LibUsbDriverIO)); hEvent.Close(); return false; }
public void Run() { Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory); _osCommands.CheckToSeeIfServiceRunning(_description); try { _log.Debug("Starting up as Azure worker role"); _exit = new ManualResetEvent(false); _coordinator.Start(); //user code starts _log.InfoFormat("[Topshelf] Running."); _exit.WaitOne(); } catch (Exception ex) { _log.Error("An exception occurred", ex); } finally { ShutdownCoordinator(); _exit.Close(); } }
public void GetConfig_CanLoadConfigsFromMultipleThreads() { const string configKey = "MyCustomConfig"; var configLoader = new FakeLoader(false, true); var configRepository = new ConfigRepository(configLoader); const int maxThreads = 10; Exception ex = null; IConfig config = null; var getConfigCompletedEvent = new ManualResetEvent(false); for(int i = 0; i < maxThreads; i++) { int remainingThreads = i; ThreadPool.QueueUserWorkItem(s => { try { config = configRepository.GetConfig(configKey, false); if(Interlocked.Decrement(ref remainingThreads) == 0) { getConfigCompletedEvent.Set(); } } catch(Exception innerEx) { getConfigCompletedEvent.Set(); ex = innerEx; throw; } }); } getConfigCompletedEvent.WaitOne(); getConfigCompletedEvent.Close(); Assert.IsNotNull(config); Assert.IsNull(ex); }
/// <summary> /// Called when the service is started. /// </summary> protected void OnStart(string[] args) { try { Thread serviceThread = new Thread(new ParameterizedThreadStart(StartAsync)); ManualResetEvent serviceStarting = new ManualResetEvent(false); serviceThread.Start(serviceStarting); serviceStarting.WaitOne(); serviceStarting.Close(); foreach (ScheduleBase schedule in ScheduleManager.GetSchedules()) { schedule.Settings.LastElapsed = new DateTime(0); ObjectHelper wrapper = new ObjectHelper(schedule); if (wrapper.HasProperty("TimeOfDay")) { wrapper.SetValue("TimeOfDay", DateTime.Now.TimeOfDay); } if (wrapper.HasProperty("DayOfMonth")) { wrapper.SetValue("DayOfMonth", DayOfMonth.AllDays); } } } catch (ThreadAbortException) { // do nothing. } }
public void Wait() { SpinWait s = new SpinWait(); while (m_state == 0) { if (s.Spin() >= s_spinCount) { if (m_eventObj == null) { ManualResetEvent newEvent = new ManualResetEvent(m_state == 1); if (Interlocked.CompareExchange<EventWaitHandle>( ref m_eventObj, newEvent, null) == null) { // If someone set the flag before seeing the new // event obj, we must ensure it’s been set. if (m_state == 1) m_eventObj.Set(); } else { // Lost the race w/ another thread. Just use // its event. newEvent.Close(); } } m_eventObj.WaitOne(); } } }
/// <summary> /// Create a <see cref="ManualResetEvent"/> wrapper around the given native event. /// </summary> /// <param name="handle">The handle of the native event.</param> /// <returns>A <see cref="ManualResetEvent"/> wrapping the given <paramref name="handle"/>.</returns> public static ManualResetEvent GetManualResetEvent( IntPtr handle ) { ManualResetEvent ev = new ManualResetEvent( false ); ev.Close(); GC.ReRegisterForFinalize( ev ); ev.SafeWaitHandle = new Microsoft.Win32.SafeHandles.SafeWaitHandle( handle, false ); return ev; }
protected override void OnStart(string[] args) { base.OnStart(args); Thread serviceThread = new Thread(new ParameterizedThreadStart(RunProcess)); ManualResetEvent serviceStarting = new ManualResetEvent(false); serviceThread.Start(serviceStarting); serviceStarting.WaitOne(); serviceStarting.Close(); }
/// <summary>The Dispose method</summary> protected override void Dispose(bool disposeManagedResources) { if (disposeManagedResources) { StopProducer(); // dispose managed resources _producerDone.Close(); _haveData.Close(); _needData.Close(); } }
/// <summary> /// Splashフォームを消す /// </summary> public static void CloseSplash() { lock (syncObject) { if (_thread == null) { return; } if (_mainForm != null) { _mainForm.Activated -= new EventHandler(_mainForm_Activated); } //Splashが表示されるまで待機する if (splashShownEvent != null) { splashShownEvent.WaitOne(); splashShownEvent.Close(); splashShownEvent = null; } //Splashフォームを閉じる //Invokeが必要か調べる if (_form != null) { if (_form.InvokeRequired) { _form.Invoke(new MethodInvoker(CloseLogoWindow)); } else { CloseLogoWindow(); } } //メインフォームをアクティブにする if (_mainForm != null) { if (_mainForm.InvokeRequired) { _mainForm.Invoke(new MethodInvoker(ActivateMainForm)); } else { ActivateMainForm(); } } _form = null; _thread = null; _mainForm = null; } }
/// <summary> /// Tries to get text contents from the Windows clipboard. If the clipboard contains any other type then text, the returned result will be <c>false</c>. /// </summary> /// <returns><c>true</c> if text could be retrieved.</returns> public bool GetClipboardText(out string text) { string result = null; ManualResetEvent finishedEvent = new ManualResetEvent(false); Thread thread = ThreadingUtils.RunSTAThreaded(() => GetClipboardText_STA(finishedEvent, ref result)); if (!finishedEvent.WaitOne(MAX_WAIT_MS)) thread.Abort(); finishedEvent.Close(); text = result; return !string.IsNullOrWhiteSpace(result); }
protected virtual void Dispose(bool disposing) { if (disposing && Interlocked.CompareExchange(ref _disposeRequested, 1, 0) == 0) { if (_cancelRequested == 0) { UnregisterLinkedTokens(); _callbacks = null; } var timer = Interlocked.Exchange(ref _timeout, null); timer?.Dispose(); _handle?.Close(); } }
void Lock(Transaction transaction) { Monitor.Enter(this); if (OwningTransaction == null) { //Acquire the transaction lock if(transaction != null) OwningTransaction = transaction; Monitor.Exit(this); return; } else //Some transaction owns the lock { //We're done if it's the same one as the method parameter if (OwningTransaction == transaction) { Monitor.Exit(this); return; } //Otherwise, need to acquire the transaction lock else { ManualResetEvent manualEvent = new ManualResetEvent(false); KeyValuePair<Transaction, ManualResetEvent> pair = new KeyValuePair<Transaction, ManualResetEvent>(transaction, manualEvent); PendingTransactions.AddLast(pair); if (transaction != null) { transaction.TransactionCompleted += (sender, e) => { lock (this) { //Pair may have already been removed if unlocked PendingTransactions.Remove(pair); } lock (manualEvent) { if (!manualEvent.SafeWaitHandle.IsClosed) { manualEvent.Set(); } } }; } Monitor.Exit(this); //Block the transaction or the calling thread manualEvent.WaitOne(); lock (manualEvent) manualEvent.Close(); } } }
/// <summary> /// Starts the video download. /// </summary> /// <exception cref="IOException">The video file could not be saved.</exception> /// <exception cref="WebException">An error occured while downloading the video.</exception> public override void Execute() { // We need a handle to keep the method synchronously var handle = new ManualResetEvent(false); var client = new WebClient(); bool isCanceled = false; client.DownloadFileCompleted += (sender, args) => { handle.Close(); client.Dispose(); // DownloadFileAsync passes the exception to the DownloadFileCompleted event, if one occurs if (args.Error != null && !args.Cancelled) { throw args.Error; } handle.Set(); }; client.DownloadProgressChanged += (sender, args) => { var progressArgs = new ProgressEventArgs(args.ProgressPercentage); // Backwards compatibility this.OnProgressChanged(progressArgs); if (this.DownloadProgressChanged != null) { this.DownloadProgressChanged(this, progressArgs); if (progressArgs.Cancel && !isCanceled) { isCanceled = true; client.CancelAsync(); } } }; this.OnDownloadStarted(EventArgs.Empty); client.DownloadFileAsync(new Uri(this.Video.DownloadUrl), this.SavePath); handle.WaitOne(); this.OnDownloadFinished(EventArgs.Empty); }
public GuiThread(Type formType) { if (!formType.IsSubclassOf(typeof(Form)) && formType != typeof(Form)) throw new ArgumentException("formType must be inherited from System.Windows.Forms.Form."); thread = new Thread(new ParameterizedThreadStart(MessagePump)); thread.SetApartmentState(ApartmentState.STA); thread.IsBackground = true; thread.Name = "GuiThread"; windowCreatedEvent = new ManualResetEvent(false); thread.Start(formType); windowCreatedEvent.WaitOne(); windowCreatedEvent.Close(); windowCreatedEvent = null; }
private void button1_Click(object sender, EventArgs e) { _prefix = textBox1.Text; _actionReady = new ManualResetEvent(false); _actionReady.Reset(); using (Utils.FrameworkDataUpdater updater = new Utils.FrameworkDataUpdater(_core)) { Thread thrd = new Thread(new ThreadStart(this.assignRegionsThreadMethod)); thrd.Start(); while (!_actionReady.WaitOne(100)) { System.Windows.Forms.Application.DoEvents(); } thrd.Join(); } _actionReady.Close(); Close(); }
internal override void Open() { Debug.Print("ListenerAdapter[" + ProtocolName + "]::Open()"); if (!isOpen) { lock (ThisLock) { if (!isOpen) { initCompleted = new ManualResetEvent(false); base.Open(); initCompleted.WaitOne(); initCompleted.Close(); initCompleted = null; isOpen = true; } } } }
public SimulatorBase(PosCommon serviceObject) { HandleCreated += new EventHandler(SimulatorBase_HandleCreated); wr = new WeakReference(serviceObject); WindowVisible = new ManualResetEvent(false); UIThread = new Thread(new ThreadStart(UIThreadMethod)); UIThread.IsBackground = true; UIThread.Start(); WindowVisible.WaitOne(); WindowVisible.Close(); WindowVisible = null; closed = false; stateTimer.Tick +=new EventHandler(stateTimer_Tick); stateTimer.Interval = 200; stateTimer.Start(); }
/// <summary> /// Starts the video download. /// </summary> public override void Execute() { // We need a handle to keep the method synchronously var handle = new ManualResetEvent(false); var client = new WebClient(); client.DownloadFileCompleted += (sender, args) => handle.Set(); client.DownloadProgressChanged += (sender, args) => this.OnProgressChanged(new ProgressEventArgs(args.ProgressPercentage)); this.OnDownloadStarted(EventArgs.Empty); client.DownloadFileAsync(new Uri(this.Video.DownloadUrl), this.SavePath); handle.WaitOne(); handle.Close(); this.OnDownloadFinished(EventArgs.Empty); }
private static void BuildGridForm() { // Create an event used by the grid form that's being created to signal back to this thread that creation is complete ManualResetEvent gridFormIsReadyEvent = new ManualResetEvent(false); Thread t = new Thread( () => { _gridForm = new GridForm(gridFormIsReadyEvent); // TODO: When running from within a WinForms app (WPF?), this call's likely to cause issues. Detect and take evasive action. Application.Run(_gridForm); }); t.SetApartmentState(ApartmentState.STA); t.Start(); // Wait for the grid form to be created. gridFormIsReadyEvent.WaitOne(); gridFormIsReadyEvent.Close(); }
/// <summary> /// Starts listening, accepting and reading from the clients. /// </summary> public void StartListening() { if (_isListening) return; Logger.Info("TcpServer is starting..."); _clientAcceptanceEvent = new ManualResetEvent(false); _cancellationTokenSource = new CancellationTokenSource(); var token = _cancellationTokenSource.Token; token.Register(() => { _isListening = false; _listenerSocket.Close(); _clientAcceptanceEvent.Close(); }); _listenerSocket.Listen(MaxPendingConnections); new Task(() => { while (true) { try { _clientAcceptanceEvent.Reset(); _listenerSocket.BeginAccept(AcceptCallback, _listenerSocket); _clientAcceptanceEvent.WaitOne(); } catch (Exception) { // *crickets* } } }, token).Start(); _isListening = true; }
/// <summary> /// Starts the video download. /// </summary> /// <exception cref="IOException">The video file could not be saved.</exception> /// <exception cref="WebException">An error occured while downloading the video.</exception> public override void Execute() { // We need a handle to keep the method synchronously var handle = new ManualResetEvent(false); var client = new WebClient(); client.DownloadFileCompleted += (sender, args) => { // DownloadFileAsync passes the exception to the DownloadFileCompleted event, if one occurs if (args.Error != null) { throw args.Error; } handle.Set(); }; client.DownloadProgressChanged += (sender, args) => this.OnProgressChanged(new ProgressEventArgs(args.ProgressPercentage)); this.OnDownloadStarted(EventArgs.Empty); try { client.DownloadFileAsync(new Uri(this.Video.DownloadUrl), this.SavePath); handle.WaitOne(); } finally { handle.Close(); } this.OnDownloadFinished(EventArgs.Empty); }
/// <summary> /// Starts the video download. /// </summary> public override void Execute() { // We need a handle to keep the method synchronously var handle = new ManualResetEvent(false); var client = new WebClient(); client.DownloadFileCompleted += (sender, args) => handle.Set(); client.DownloadProgressChanged += (sender, args) => { double progress = (args.BytesReceived * 1.0 / args.TotalBytesToReceive) * 100; this.OnProgressChanged(new ProgressEventArgs(progress)); }; this.OnDownloadStarted(EventArgs.Empty); client.DownloadFileAsync(new Uri(this.Video.DownloadUrl), this.SavePath); handle.WaitOne(); handle.Close(); this.OnDownloadFinished(EventArgs.Empty); }
public void EventLoggerLogDebug() { ManualResetEvent handle = new ManualResetEvent(false); try { EventLogger logger = new EventLogger(); logger.Log += (sender, args) => { Assert.AreEqual(EventLoggerEventType.Debug, args.EventType); Assert.AreEqual("Debug", args.Message); Assert.IsNull(args.Exception); handle.Set(); }; logger.Debug("Debug"); WaitHandle.WaitAll(new WaitHandle[] { handle }); } finally { handle.Close(); } }
IEnumerator RestoreUpdate() { if (Application.internetReachability == NetworkReachability.NotReachable) { Log.LogInfo("connect time out"); MainLoader.ChangeStep(LoadStep.NotNeedUpdate); yield break; } else if (Application.internetReachability == NetworkReachability.ReachableViaCarrierDataNetwork) { //3G Tip } //Restore DownLoad From Progress.xml System.Net.Sockets.Socket sClient = new System.Net.Sockets.Socket(System.Net.Sockets.AddressFamily.InterNetwork, System.Net.Sockets.SocketType.Stream, System.Net.Sockets.ProtocolType.IP); System.Net.EndPoint server = new System.Net.IPEndPoint(Dns.GetHostAddresses(GameData.Domain)[0], System.Convert.ToInt32(strPort)); System.Threading.ManualResetEvent connectDone = new System.Threading.ManualResetEvent(false); try { connectDone.Reset(); sClient.BeginConnect(server, delegate(IAsyncResult ar) { try { System.Net.Sockets.Socket client = (System.Net.Sockets.Socket)ar.AsyncState; client.EndConnect(ar); } catch (System.Exception e) { Log.LogInfo(e.Message + "|" + e.StackTrace); } finally { connectDone.Set(); } } , sClient); //timeout if (!connectDone.WaitOne(2000)) { Log.LogInfo("connect time out"); MainLoader.ChangeStep(LoadStep.CannotConnect); yield break; } else { if (!sClient.Connected) { Log.LogInfo("connect disabled by server"); MainLoader.ChangeStep(LoadStep.CannotConnect); yield break; } } } catch { sClient.Close(); MainLoader.ChangeStep(LoadStep.CannotConnect); yield break; } finally { connectDone.Close(); } //Log.LogInfo("download:" + string.Format(strVFile, strHost, strPort, strProjectUrl, strPlatform, strVFileName)); using (WWW vFile = new WWW(string.Format(strVFile, strHost, strPort, strProjectUrl, strPlatform, strVFileName))) { //Log.LogInfo("error:" + vFile.error); yield return(vFile); if (vFile.error != null && vFile.error.Length != 0) { //Log.LogInfo("error " + vFile.error); vFile.Dispose(); //not have new version file //can continue game MainLoader.ChangeStep(LoadStep.NotNeedUpdate); yield break; } if (vFile.bytes != null && vFile.bytes.Length != 0) { File.WriteAllBytes(strUpdatePath + "/" + "v.zip", vFile.bytes); DeCompressFile(strUpdatePath + "/" + "v.zip", strUpdatePath + "/" + "v.xml"); vFile.Dispose(); } else { MainLoader.ChangeStep(LoadStep.NotNeedUpdate); yield break; } } XmlDocument xmlVer = new XmlDocument(); xmlVer.Load(strUpdatePath + "/" + "v.xml"); XmlElement ServerVer = xmlVer.DocumentElement; if (ServerVer != null) { string strServer = ServerVer.GetAttribute("ServerV"); UpdateClient = HttpManager.AllocClient(string.Format(strDirectoryBase, strHost, strPort, strProjectUrl, strPlatform, strServer, "")); //if (strServer != null && GameData.Version().CompareTo(strServer) == -1) //{ // strServerVer = strServer; // foreach (XmlElement item in ServerVer) // { // string strClientV = item.GetAttribute("ClientV"); // if (strClientV == GameData.Version()) // { // strUpdateFile = item.GetAttribute("File"); // break; // } // } // if (strUpdateFile != null && strUpdateFile.Length != 0) // StartCoroutine("DownloadNecessaryData"); //} //else //{ // Log.LogInfo("not need update"); // MainLoader.ChangeStep(LoadStep.NotNeedUpdate); //} } }
/// <summary> /// Sends STARTTLS command to SMTP server. /// </summary> /// <param name="certCallback">SSL server certificate validation callback. Value null means any certificate is accepted.</param> /// <exception cref="ObjectDisposedException">Is raised when this object is disposed and this method is accessed.</exception> /// <exception cref="InvalidOperationException">Is raised when SMTP client is not connected or is already secure connection.</exception> /// <exception cref="SMTP_ClientException">Is raised when SMTP server returns error.</exception> /// <remarks>After successful STARTTLS all SMTP session data(EHLO,MAIL FROM, ....) will be reset. /// If unknwon(not SMTP error) error happens during STARTTLS negotiation, SMTP client should disconnect.</remarks> public void StartTLS(RemoteCertificateValidationCallback certCallback) { if(this.IsDisposed){ throw new ObjectDisposedException(this.GetType().Name); } if(!this.IsConnected){ throw new InvalidOperationException("You must connect first."); } if(this.IsSecureConnection){ throw new InvalidOperationException("Connection is already secure."); } ManualResetEvent wait = new ManualResetEvent(false); using(StartTlsAsyncOP op = new StartTlsAsyncOP(certCallback)){ op.CompletedAsync += delegate(object s1,EventArgs<StartTlsAsyncOP> e1){ wait.Set(); }; if(!this.StartTlsAsync(op)){ wait.Set(); } wait.WaitOne(); wait.Close(); if(op.Error != null){ throw op.Error; } } }