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 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);
}
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);
}
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 ThreadHandlerConstructorTest()
{
int threads = 2; // TODO: Passenden Wert initialisieren
ThreadHandler target = new ThreadHandler(threads);
Assert.AreEqual(target.getThreads(), threads);
}
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);
}
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);
}
