private void asyncRun(ThreadHandler handler, object parameter) { ParameterizedThreadStart ts = new ParameterizedThreadStart(handler); Thread thread = new Thread(ts); thread.Start(); }
public void performTest1() { Bitmap bitmap = new Bitmap(100, 100); ImageManipulatorType.Name filter = ImageManipulatorType.Name.GRAYSCALE; // TODO: Passenden Wert initialisieren int threads = 2; // TODO: Passenden Wert initialisieren ThreadHandler thHandler = new ThreadHandler(threads); ImageManipulator t = new ImageManipulator(bitmap, filter, thHandler); // TODO: Passenden Wert initialisieren PrivateObject param0 = new PrivateObject(t); // TODO: Passenden Wert initialisieren ImageManipulator_Accessor target = new ImageManipulator_Accessor(param0); BitmapData bmData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); int stride = bmData.Stride; int bytes = Math.Abs(bmData.Stride) * bmData.Height; System.IntPtr Scan0 = bmData.Scan0; target.perform(Scan0, stride); // Die Funktion stößt nur andere Funktionen ab hier an. Was testen? bitmap.UnlockBits(bmData); }
public async Task <ForumReply> GetReplyCookiesAsync(long threadId = 0, long postId = 0) { if (threadId == 0 && postId == 0) { return(new ForumReply()); } string url; url = threadId > 0 ? string.Format(EndPoints.ReplyBase, threadId) : string.Format(EndPoints.QuoteBase, postId); var result = await _webManager.GetDataAsync(url); var document = _webManager.Parser.Parse(result.ResultHtml); var inputs = document.QuerySelectorAll("input"); var posts = ThreadHandler.ParsePreviousPosts(document); var forumReplyEntity = new ForumReply(); string quote = System.Net.WebUtility.HtmlDecode(document.QuerySelector("textarea").TextContent); forumReplyEntity.MapThreadInformation( inputs["formkey"].GetAttribute("value"), inputs["form_cookie"].GetAttribute("value"), quote, inputs["threadid"].GetAttribute("value") ); forumReplyEntity.ForumPosts = posts; return(forumReplyEntity); }
// Method which loops until user presses escape // Checks for input private static void InputListener(object cInfo) { // Cast object as thread object ThreadHandler thandler = cInfo as ThreadHandler; if (thandler == null) { return; } // create console info object ConsoleKeyInfo info = new ConsoleKeyInfo(); // Loop while all the threads are still alive while (thandler.Alive) { info = Console.ReadKey(); // Check if enter key was pressed change the character if (info.Key == ConsoleKey.Enter) { thandler.CurrentCharacter = thandler.SubmiteAbleCharacter; } else { thandler.SubmiteAbleCharacter = info.KeyChar; } // Kill loop if user pressed escape key if (info.Key == ConsoleKey.Escape) { thandler.Alive = false; } } }
private IClient BuildClient(ProcessHandler onprocess, ThreadHandler onthread) { Client curclient; //- inject our assembly into the client process (where an instance of the Client class is created! Injection.Inject(onprocess, onthread, Assembly.GetExecutingAssembly(), typeof(InjectedProcess)); //- create a proxy to the remote client object curclient = (Client)Server.GetObject(typeof(Client), (int)onprocess.PID); //- wait for server to become available System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); while ((!IsValid(curclient) && (sw.ElapsedMilliseconds < 1000))) { Thread.Sleep(0); } sw.Stop(); if (IsValid(curclient)) { return(curclient.ActualClient); } else { return(null); } }
private void ThreadBase(object handler) { ThreadHandler dadosHandler = handler as ThreadHandler; if (dadosHandler == null || dadosHandler.Method == null) { return; } while (true) { try { while (true) { Thread.Sleep(dadosHandler.SleepMilliseconds); dadosHandler.Method.Invoke(); } } catch (ThreadAbortException) { break; } catch (Exception ex) { ErroDAO.Instance.InserirFromException(dadosHandler.Method.Method.Name, ex); if (dadosHandler.ExitOnException) { break; } } } }
public async Task <ForumReply> GetReplyCookiesAsync(long threadId = 0, long postId = 0, CancellationToken token = default) { if (threadId == 0 && postId == 0) { throw new FormatException(Awful.Core.Resources.ExceptionMessages.ThreadAndPostIdMissing); } string url; url = threadId > 0 ? string.Format(CultureInfo.InvariantCulture, EndPoints.ReplyBase, threadId) : string.Format(CultureInfo.InvariantCulture, EndPoints.QuoteBase, postId); var result = await this.webManager.GetDataAsync(url, token).ConfigureAwait(false); var document = await this.webManager.Parser.ParseDocumentAsync(result.ResultHtml, token).ConfigureAwait(false); var inputs = document.QuerySelectorAll("input"); var posts = ThreadHandler.ParsePreviousPosts(document); var forumReplyEntity = new ForumReply(); string quote = System.Net.WebUtility.HtmlDecode(document.QuerySelector("textarea").TextContent); forumReplyEntity.MapThreadInformation( inputs["formkey"].GetAttribute("value"), inputs["form_cookie"].GetAttribute("value"), quote, inputs["threadid"].GetAttribute("value")); forumReplyEntity.ForumPosts.AddRange(posts); return(forumReplyEntity); }
public ThreadHandler( int threads) { this.threads = threads; alive = new ArrayList(threads); this.startTime(); _object = this; }
/// <summary> /// Executes a command on the command thread. /// </summary> /// <param name="command">The command to be executed.</param> public void Execute(ThreadHandler commandHandler, params object[] argument) { // Execute the command sequentially on the command thread. Remember that 'ThreadQueues' execute the commands // in the order they were placed on the queue. The descriptive name of the thread is useful for debugging, // especially when several command threads are queued. this.Enqueue(commandHandler, argument); }
private void DoChat() { NetworkStream stream = null; try { string message = string.Empty; while (true) { stream = TcpSocket.GetStream(); byte[] sizeBuf = new byte[TcpSocket.ReceiveBufferSize]; stream.Read(sizeBuf, 0, (int)TcpSocket.ReceiveBufferSize); int size = BitConverter.ToInt32(sizeBuf, 0); MemoryStream memoryStream = new MemoryStream(); while (size > 0) { byte[] buffer; if (size < TcpSocket.ReceiveBufferSize) { buffer = new byte[size]; } else { buffer = new byte[TcpSocket.ReceiveBufferSize]; } int rec = stream.Read(buffer, 0, buffer.Length); size -= rec; memoryStream.Write(buffer, 0, buffer.Length); } memoryStream.Close(); byte[] data = memoryStream.ToArray(); memoryStream.Dispose(); message = Encoding.UTF8.GetString(data); if (message == "") { throw new Exception("공백 출력 == 상대방 소켓 끊어짐"); } serverEvent.ReceiveServerLog(message); OnReceived(message, ClientList[TcpSocket].ToString(), false); } } catch (Exception ex) { serverEvent.ErrorLog("DoChat", ex.Message); if (TcpSocket != null) { OnDisconnected(TcpSocket); TcpSocket.Close(); stream.Close(); if (ThreadHandler.IsAlive == true) { ThreadHandler.Interrupt(); ThreadHandler.Abort(); } } } }
public void OnStart() { isConnecting = true; var t1 = Task.Run(() => { while (isConnecting) { if (Interlocked.Exchange(ref inTimer, 1) == 0) { MQHandler queue = new MQHandler(); string rcvd; do { rcvd = queue.ReceiveMessage(IntData.QUEUE_NAME, IntData.QUEUE_NAME + " Message");//Dequeue the query if (rcvd != "") { ThreadHandler.ThreadLocker();//Pause the program when thread is locked ExecuteSQL(rcvd); } } while (rcvd != ""); Interlocked.Exchange(ref inTimer, 0); } Thread.Sleep(1000); } }); }
/// <summary> /// Threads the testing. /// </summary> private static void ThreadTesting() { // // Example 1 // th = new ThreadHandler(); // registering and unregistering the event... th.OnJob += new HandlerForOnJob(th_OnJob); th.OnJob -= new HandlerForOnJob(th_OnJob); // // Example 2 - Testing... // th = new ThreadHandler(new MyThread(100)); ThreadMenu(); System.Console.WriteLine("Waiting for the worker thread to finish..."); if ((th.Thread.ThreadState & System.Threading.ThreadState.Unstarted) == 0) { th.Thread.Join(); } System.Console.WriteLine("FINALLY FINISHED:"); System.Console.WriteLine("Thread state = " + th.Thread.ThreadState.ToString()); System.Console.WriteLine("IsAlive = " + th.Thread.IsAlive.ToString()); System.Console.WriteLine("IsAborted = " + (((th.Thread.ThreadState & System.Threading.ThreadState.Aborted) > 0) ? true.ToString() : false.ToString())); System.Console.WriteLine("Press ENTER, ThreadState is = " + ((int)th.Thread.ThreadState).ToString()); System.Console.ReadLine(); }
public ImageManipulator(Bitmap bitmap, ImageManipulatorType.Name filter, ThreadHandler thHandler, int[] values = null ) { this.bitmap = bitmap; this.filter = filter; this.thHandler = thHandler; this.values = values; }
public void ThreadHandlerConstructorTest() { int threads = 2; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); Assert.AreEqual(target.getThreads(), threads); }
public void getInstanceTest() { int threads = 2; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); ThreadHandler actual = ThreadHandler.getInstance(); Assert.AreEqual(actual, target); }
public WorkerThread(ThreadHandler threadHandler, params object[] arguments) { ThreadArgument threadArgument = new ThreadArgument(threadHandler, arguments); Thread thread = new Thread(new ThreadStart(threadArgument.StartThread)); thread.IsBackground = true; thread.Start(); }
public void refreshTest() { int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren PictureBox pic = new PictureBox(); // TODO: Passenden Wert initialisieren target.refresh(pic); }
/// <summary> /// Inicia as threads de controle do sistema, se necessário. /// </summary> public void IniciarThreads(HttpContext context) { if (UserInfo.GetUserInfo == null || context == null || System.Configuration.ConfigurationManager.AppSettings["RodarThreads"] == "false") { return; } _context = context; bool isLocal = Utils.IsLocalUrl(_context); // Fila de e-mail e SMS // Deve entrar sempre, pois no caso da vidrocel, apesar de não enviar email quando o pedido estiver pronto, // estiver confirmado ou enviar sms, ela ainda envia email com o xml da nota if (!isLocal && (_emailSms == null || !_emailSms.IsAlive)) { ThreadHandler handler = new ThreadHandler(ProcessaFilaEmailSms, Segundo * 30); _emailSms = new Thread(ThreadBase); _emailSms.Start(handler); } // Bloqueio de clientes if (!isLocal && (_bloquearCliente == null || !_bloquearCliente.IsAlive) && (FinanceiroConfig.PeriodoInativarClienteUltimaCompra > 0 || PedidoConfig.NumeroDiasPedidoProntoAtrasado > 0)) { ThreadHandler handler = new ThreadHandler(BloquearCliente, Hora * 4); _bloquearCliente = new Thread(ThreadBase); _bloquearCliente.Start(handler); } if ((_emailCobranca == null || !_emailCobranca.IsAlive) && FinanceiroConfig.UsarControleCobrancaEmail) { ThreadHandler handler = new ThreadHandler(EmailCobranca, Hora * 8); _emailCobranca = new Thread(ThreadBase); _emailCobranca.Start(handler); } if (_usoLimiteCliente == null || !_usoLimiteCliente.IsAlive) { var handler = new ThreadHandler(AtualizarUsoLimiteCliente, Minuto * 20); _usoLimiteCliente = new Thread(ThreadBase); _usoLimiteCliente.Start(handler); } if (_limparLogErro == null || !_limparLogErro.IsAlive) { var handler = new ThreadHandler(LimpaLogErro, Dia); _limparLogErro = new Thread(ThreadBase); _limparLogErro.Start(handler); } if (!isLocal && (_coletaMensagem == null || !_coletaMensagem.IsAlive)) { var handler = new ThreadHandler(ColetaMensagemErro, Minuto * 3); _coletaMensagem = new Thread(ThreadBase); _coletaMensagem.Start(handler); } }
public void getTimeTest() { int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren long actual; actual = target.getTime(); Assert.IsNotNull( actual > -1); }
public async Task <NewThread> GetThreadCookiesAsync(int forumId) { string url = string.Format(EndPoints.NewThread, forumId); var result = await _webManager.GetDataAsync(url); var document = await _webManager.Parser.ParseAsync(result.ResultHtml); return(ThreadHandler.ParseNewThread(document)); }
public void getThreadsTest() { int threads = 2; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren int expected = 2; // TODO: Passenden Wert initialisieren int actual; actual = target.getThreads(); Assert.AreEqual(expected, actual); }
public async Task <NewThread> GetThreadCookiesAsync(int forumId, CancellationToken token = default) { string url = string.Format(CultureInfo.InvariantCulture, EndPoints.NewThread, forumId); var result = await this.webManager.GetDataAsync(url, token).ConfigureAwait(false); var document = await this.webManager.Parser.ParseDocumentAsync(result.ResultHtml, token).ConfigureAwait(false); return(ThreadHandler.ParseNewThread(document)); }
protected override void ProcessBatch() { if (ShouldParallelize) { ThreadHandler.For(0, _batches.Length, i => { ref var batch = ref _batches[i]; Process(batch.EntityId, ref *batch.Component1, ref *batch.Component2); });
public void getTimeTest() { int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren long actual; actual = target.getTime(); Assert.IsNotNull(actual > -1); }
public void CreateCustomerTest() { var threadHandler = new ThreadHandler(10); for (var i = 0; i < threadHandler.AmountOfCustomers; i++) { threadHandler.GenerateExtraCustomers(_bank, _bazaar); } Assert.IsTrue(threadHandler.Customers.Count == 10); }
protected override void OnStart(string[] args) { var proxy = new ProxyHandler(); var threadHandler = new ThreadHandler(); var installHandler = new InstallHandler(); proxy.Start(); threadHandler.StartRequestThread(); installHandler.Install(); }
protected override void OnStop() { var proxy = new ProxyHandler(); var threadHandler = new ThreadHandler(); var installHandler = new InstallHandler(); threadHandler.StopRequestThread(); proxy.Stop(); installHandler.Uninstall(true); }
public void Enqueue(ThreadHandler threadDelegate, params object[] argument) { // Use the name of the thread handler to identify the thread. string threadName = String.Format("{0}.{1}", threadDelegate.Method.DeclaringType.Name, threadDelegate.Method.Name); // Create the argument used to start the thread. This includes a start up routine that joins the new thread // to the chain of threads. Being placed in a queue and joined to the previous thread guarantees that the // threads execute in the order they were created. QueueThread(new ThreadQueueArgument(this, threadDelegate, threadName, argument)); }
public void threadsAreAliveTest() { int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren bool expected = false; // TODO: Passenden Wert initialisieren bool actual; actual = target.threadsAreAlive(); Assert.AreEqual(expected, actual); }
static void Main(string[] args) { ThreadHandler handler = new ThreadHandler(); if (handler.NotifiyData.Count == 0) { return; } SendEmail(handler.NotifiyData); }
public async Task <List <Thread> > GetForumThreadListAsync(Forum forum, int page) { var pageUrl = string.Format(EndPoints.ForumPage, forum.ForumId) + string.Format(EndPoints.PageNumber, page); var result = await _webManager.GetDataAsync(pageUrl); var document = await _webManager.Parser.ParseAsync(result.ResultHtml); ForumHandler.GetForumPageInfo(document, forum); return(ThreadHandler.ParseForumThreadList(document, forum.ForumId)); }
static void UnloadChunksOutsideViewDistance() { ThreadedChunkWork tcw; if (!NonChunkSpecificWork.TryGetValue(JobType.UnloadOutsideViewDistance, out tcw)) { ThreadedViewDistanceUnloaderWork tvduw = new ThreadedViewDistanceUnloaderWork(PlayerChunkPos, ViewDistance, GetLoadedChunkPositions, ChunkGameObjectHandler.GetDrawnChunkPositions); NonChunkSpecificWork.Add(JobType.UnloadOutsideViewDistance, tvduw); ThreadHandler.EnqueuWork(tvduw); } }
public MyThreadPool(int numOfThreads, ThreadHandler initThread, ThreadHandler executeThread) { m_numOfThreads = numOfThreads; m_initThread = initThread; m_executeThread = executeThread; m_threads = new Thread[m_numOfThreads]; m_threadExecInfos = new ThreadExecInfo[m_numOfThreads]; m_eventsDone = new AutoResetEvent[m_numOfThreads]; }
/// <summary> /// Constructor for ThreadHandlerEventArgs. /// </summary> /// <param name="threadHandler">ThreadHandler object</param> public ThreadHandlerEventArgs(ThreadHandler threadHandler) { ThreadHandler = threadHandler; }
/// <summary> /// Constructor for ThreadHandlerExceptionArgs. /// </summary> /// <param name="threadHandler">ThreadHandler object</param> /// <param name="exception">Exception object</param> public ThreadHandlerExceptionArgs(ThreadHandler threadHandler, Exception exception) { ThreadHandler = threadHandler; Exception = exception; }
public void registerTest() { PixelState p = PixelState.getInstance(); int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren Thread thread = new Thread(p.reset); // TODO: Passenden Wert initialisieren target.register(thread); Assert.IsFalse(target.threadsAreAlive()); }
public ImageManipulater(Bitmap b, ImageManipulaterType.Name filter, ThreadHandler thHandler) { this.b = b; this.filter = filter; this.thHandler = thHandler; }
public void save_PixelStateTest() { int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren Bitmap b = new Bitmap(10, 10); Image img = (Image)b; ImageManipulatorType.Name manipulator = ImageManipulatorType.Name.RGB_RED; // TODO: Passenden Wert initialisieren ImageObject imgO = new ImageObject(img, manipulator); target.save_PixelState(imgO); PixelState state = PixelState.getInstance(); Assert.IsInstanceOfType(state, typeof(PixelState)); }
public void try_save_PixelStateTest() { ThreadHandler t = new ThreadHandler(2); PrivateObject param0 = new PrivateObject(t); ThreadHandler_Accessor target = new ThreadHandler_Accessor(param0); // TODO: Passenden Wert initialisieren Bitmap b = new Bitmap(10, 10); Image img = (Image)b; ImageManipulatorType.Name manipulator = ImageManipulatorType.Name.RGB_RED; // TODO: Passenden Wert initialisieren ImageObject imgO = new ImageObject(img, manipulator); target.try_save_PixelState(imgO); PixelState state = PixelState.getInstance(); Assert.IsInstanceOfType(state.get_last(), typeof(ImageObject)); Assert.IsNotNull(state.get_last()); }
public void invoke_refreshTest() { int threads = 0; // TODO: Passenden Wert initialisieren ThreadHandler target = new ThreadHandler(threads); // TODO: Passenden Wert initialisieren PictureBox pic = null; // TODO: Passenden Wert initialisieren target.refresh(pic); }