/// <summary>
/// Função que inicializa as operações da thread. Quando o contrutor EasyThread(EasyThreadFun, bool, object) é utilizado, esta função é executada automaticamente.
/// </summary>
/// <param name="fun">Função a ser executada</param>
/// <param name="runAsWhileTrue">Indica se a thread deve chamar a função "fun" em um "while true". Caso seja true, a função é executada repetidamente.</param>
/// <param name="thParams">Parametros que serão passados para a função "fun"</param>
public void Start(EasyThreadFun fun, bool runAsWhileTrue, object thParams = null)
{
if (this.canRun())
{
thread = new Thread(delegate()
{
this.__status = ThreadStatus.running;
if (runAsWhileTrue)
{
while (this.canRun())
{
if (!__pause)
{
fun(this, thParams);
}
else
{
this.sleep(1);
}
}
this.__status = ThreadStatus.exited;
}
else
{
fun(this, thParams);
this.__status = ThreadStatus.exited;
}
});
thread.Start();
}
}
/// <summary>
/// Starts the threads.
/// </summary>
/// <param name="fun">The thread function</param>
/// <param name="runAsWhileTrue">Run the thread inside a while true.</param>
/// <param name="thParams">Arguments that will passed in each "fun" call/param>
public void Start(EasyThreadFun fun, bool runAsWhileTrue, object thParams = null, EasyThreadFun onEnd = null, ThreadPriority priority = ThreadPriority.Normal, int interval = -1)
{
this.onEnd = onEnd;
if (this.canRun())
{
thread = new Thread(delegate()
{
this.__status = ThreadStatus.running;
if (runAsWhileTrue)
{
while (this.canRun())
{
if (!__pause)
{
fun(this, thParams);
if (interval > -1)
{
Thread.Sleep(interval);
}
}
else
{
this.sleep(1);
}
}
this.__status = ThreadStatus.exited;
}
else
{
fun(this, thParams);
this.__status = ThreadStatus.exited;
}
if (this.onEnd != null)
{
this.onEnd(this, thParams);
}
});
thread.Priority = priority;
thread.Start();
}
}
/// <summary>
/// Create a Thread auto timerized, like a timer. The minimun time precision is 10 milisseconds. Can be used when a long interval ins needed.
/// The timer can be stopped in any moment.
/// </summary>
/// <param name="fun">The function to be called</param>
/// <param name="interval">The interval to execute function (the minimum value is 10 milisseconds)</param>
/// <param name="thParams">Optional parameters to be passed in each "fun" call</param>
/// <param name="onEnd">A optional function to be called when the timer is stopped</param>
/// <param name="priority">The thread priority.</param>
/// <returns></returns>
public static EasyThread StartTimer(EasyThreadFun fun, int interval, object thParams = null, EasyThreadFun onEnd = null, ThreadPriority priority = ThreadPriority.Normal)
{
return(StartNew(delegate(EasyThread snd, object args)
{
if (snd.Tags.ContainsKey("timeout"))
{
Thread.Sleep(10);
if (DateTime.Now.Subtract((DateTime)snd.Tags["timeout"]).TotalMilliseconds >= interval)
{
snd.Tags["timeout"] = DateTime.Now;
fun(snd, args);
}
}
else
{
snd.Tags["timeout"] = DateTime.Now;
fun(snd, args);
}
}, true, thParams, onEnd, priority));
}
/// <summary>
/// Contructor that auto starts the thread.
/// </summary>
/// <param name="fun">The thread function</param>
/// <param name="runAsWhileTrue">Run the thread inside a while true.</param>
/// <param name="thParams">Arguments that will passed in each "fun" call/param>
public EasyThread(EasyThreadFun fun, bool runAsWhileTrue = true, object thParams = null, EasyThreadFun onEnd = null, ThreadPriority priority = ThreadPriority.Normal, int interval = -1)
{
EasyThread.threadList.Add(this);
this.Start(fun, runAsWhileTrue, thParams, onEnd, priority, interval);
}
/// <summary>
/// Cria um novo objeto EasyThread
/// </summary>
/// <param name="fun">Função a ser execuata</param>
/// <param name="runAsWhileTrue">Indica se deve executar como um while true</param>
/// <param name="thParams">Parametros que serão passados para a thread</param>
/// <returns></returns>
public static EasyThread StartNew(EasyThreadFun fun, bool runAsWhileTrue, object thParams = null, EasyThreadFun onEnd = null, ThreadPriority priority = ThreadPriority.Normal)
{
return(new EasyThread(fun, runAsWhileTrue, thParams, onEnd, priority));
}
/// <summary>
/// Construtor que já inicializa as operações da thread.
/// </summary>
/// <param name="fun">Função a ser executada</param>
/// <param name="runAsWhileTrue">Indica se a thread deve chamar a função "fun" em um "while true". Caso seja true, a função é executada repetidamente.</param>
/// <param name="thParams">Parametros que serão passados para a função "fun"</param>
public EasyThread(EasyThreadFun fun, bool runAsWhileTrue, object thParams = null)
{
EasyThread.threadList.Add(this);
this.Start(fun, runAsWhileTrue, thParams);
}
/// <summary>
/// Cria um novo objeto EasyThread
/// </summary>
/// <param name="fun">Função a ser execuata</param>
/// <param name="runAsWhileTrue">Indica se deve executar como um while true</param>
/// <param name="thParams">Parametros que serão passados para a thread</param>
/// <returns></returns>
public static EasyThread StartNew(EasyThreadFun fun, bool runAsWhileTrue, object thParams = null)
{
return(new EasyThread(fun, runAsWhileTrue, thParams));
}
