线程扩展

public class ThreadExtend
{
public ThreadExtend()
{
}

/// <summary>
/// 线程对象
/// </summary>
protected System.Threading.Thread Th;


public System.Threading.Thread Thread {
get { return Th; } }

/// <summary>
/// 开始线程 执行委托
/// </summary>
/// <typeparam name="T1"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <typeparam name="T3"></typeparam>
/// <typeparam name="T4"></typeparam>
/// <param name="start"></param>
/// <param name="args"></param>
/// <returns></returns>
public ThreadExtend Start<T1, T2, T3, T4>(Func<T1, T2, T3, T4, object> start, params object[] args)
{
Th = new System.Threading.Thread(() =>
{
Result = start(
args.Length > 0 ? (T1)args[0] : default(T1),
args.Length > 1 ? (T2)args[1] : default(T2),
args.Length > 2 ? (T3)args[2] : default(T3),
args.Length > 3 ? (T4)args[3] : default(T4));
}) { IsBackground = true };
//开启线程
Th.Start();

return this;
}

 


/// <summary> 
/// 开启线程
/// </summary>
public static ThreadExtend CreateFunc<T1, T2, T3, T4>(Func<T1, T2, T3, T4, object> start, params object[] args)
{
return new ThreadExtend().Start(start, args);
}

/// <summary> 
/// 开启线程
/// </summary>
public static ThreadExtend CreateFunc<T1, T2, T3>(Func<T1, T2, T3, object> start, params object[] args)
{
Func<T1, T2, T3, object, object> st = (a, b, c, d) => start(a, b, c);
return new ThreadExtend().Start(st, args);
}

/// <summary>
/// 开启线程
/// </summary>
public static ThreadExtend CreateFunc<T1, T2>(Func<T1, T2, object> start, params object[] args)
{
Func<T1, T2, object, object, object> st = (a, b, c, d) => start(a, b);
return new ThreadExtend().Start(st, args);
}

/// <summary> 
/// 开启线程
/// </summary>
public static ThreadExtend CreateFunc<T1>(Func<T1, object> start, params object[] args)
{
Func<T1, object, object, object, object> st = (a, b, c, d) => start(a);
return new ThreadExtend().Start(st, args);
}

/// <summary> 
/// 开启线程
/// </summary>
public static ThreadExtend CreateFunc(Func<object> start)
{
Func<object, object, object, object, object> st = (a, b, c, d) => start();
return new ThreadExtend().Start(st, new object[0]);
}

/// <summary> 
/// 开启线程
/// </summary> 
public static ThreadExtend CreateAction<T1, T2, T3, T4>(Action<T1, T2, T3, T4> start, params object[] args)
{
Func<T1, T2, T3, T4, object> st = (a, b, c, d) => { start(a, b, c, d); return null; };
return new ThreadExtend().Start(st, args);
}

/// <summary> 
/// 开启线程
/// </summary> 
public static ThreadExtend CreateAction<T1, T2, T3>(Action<T1, T2, T3> start, params object[] args)
{
Func<T1, T2, T3, object, object> st = (a, b, c, d) => { start(a, b, c); return null; };
return new ThreadExtend().Start(st, args);
}

/// <summary> 
/// 开启线程
/// </summary> 
public static ThreadExtend CreateAction<T1, T2>(Action<T1, T2> start, params object[] args)
{
Func<T1, T2, object, object, object> st = (a, b, c, d) => { start(a, b); return null; };
return new ThreadExtend().Start(st, args);
}

/// <summary> 
/// 开启线程
/// </summary> 
public static ThreadExtend CreateAction<T1>(Action<T1> start, params object[] args)
{
Func<T1, object, object, object, object> st = (a, b, c, d) => { start(a); return null; };
return new ThreadExtend().Start(st, args);
}

/// <summary> 
/// 开启线程 j=>...
/// </summary>
public static ThreadExtend CreateAction(Action start)
{
Func<object, object, object, object, object> st = (a, b, c, d) => { start(); return null; };
return new ThreadExtend().Start(st, new object[0]);
}

/// <summary> 
/// 开启线程 j=>...
/// </summary>
public static ThreadExtend Create<T>(Action<T> start, T arg = default(T))
{
return CreateAction(start, arg);
//Func<T, object, object, object, object> st = (a, b, c, d) => { start(arg); return null; };
//return new ThreadExtend().Start(st, new object[0]);
}

/// <summary> 
/// 开启线程 j=>...
/// </summary>
public static ThreadExtend Create(Action start)
{
return CreateAction(start);
//Func<object, object, object, object, object> st = (a, b, c, d) => { start(); return null; };
//return new ThreadEx().Start(st, new object[0]);
}

/// <summary> 强行终止线程 
/// </summary>
/// <param name="timeout">等待时间</param>
public void Abort(int timeout = int.MaxValue)
{
if (timeout > 0)
{
if (!Wait(timeout))
{
Th.Abort();
}
}
else
{
throw "Timeout 必须 > 0".ToException();
}
}

/// <summary> 
/// 等待指定时间 返回线程是否正常运行结束.
/// </summary> 
/// <param name="timeout"> </param>
/// <returns></returns>
public bool Wait(int timeout = int.MaxValue)
{
return Th.Join(timeout);
}

/// <summary> 
/// 返回结果
/// </summary>
public object Result { get; set; }

/// <summary>
/// 当前线程执行状态
/// </summary>
public bool IsAlive
{
get { return Th.IsAlive; }
}
}