/// <summary>
///StartTimeSlice 的测试
///</summary>
public void StartTimeSliceTest6Helper <T>()
{
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceStateCallback <T> timerStateCallback = null; // TODO: 初始化为适当的值
T tState = default(T); // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice <T>(delayTimeSpan, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void StartTimeSliceTest3()
{
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceStateCallback timerStateCallback = null; // TODO: 初始化为适当的值
object tState = null; // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice(delayTimeSpan, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void CallbackTest1()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
long iCount = 0; // TODO: 初始化为适当的值
TimeSliceStateCallback timerStateCallback = null; // TODO: 初始化为适当的值
object oState = null; // TODO: 初始化为适当的值
DelayStateCallTimer target = new DelayStateCallTimer(processPriority, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, oState); // TODO: 初始化为适当的值
TimeSliceStateCallback actual;
actual = target.Callback;
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
///Callback 的测试
///</summary>
public void CallbackTestHelper <T>()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
long iCount = 0; // TODO: 初始化为适当的值
TimeSliceStateCallback <T> timerStateCallback = null; // TODO: 初始化为适当的值
T tState = default(T); // TODO: 初始化为适当的值
DelayStateCallTimer <T> target = new DelayStateCallTimer <T>(processPriority, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, tState); // TODO: 初始化为适当的值
TimeSliceStateCallback <T> actual;
actual = target.Callback;
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void StartTimeSliceTest15()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSliceStateCallback timerStateCallback = null; // TODO: 初始化为适当的值
object tState = null; // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice(processPriority, delayTimeSpan, intervalTimeSpan, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
///StartTimeSlice 的测试
///</summary>
public void StartTimeSliceTest4Helper <T>()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
long iCount = 0; // TODO: 初始化为适当的值
TimeSliceStateCallback <T> timerStateCallback = null; // TODO: 初始化为适当的值
T tState = default(T); // TODO: 初始化为适当的值
TimeSlice expected = null; // TODO: 初始化为适当的值
TimeSlice actual;
actual = TimeSlice.StartTimeSlice <T>(processPriority, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, tState);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
public void ToStringTest1()
{
TimerPriority processPriority = new TimerPriority(); // TODO: 初始化为适当的值
TimeSpan delayTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
TimeSpan intervalTimeSpan = new TimeSpan(); // TODO: 初始化为适当的值
long iCount = 0; // TODO: 初始化为适当的值
TimeSliceStateCallback timerStateCallback = null; // TODO: 初始化为适当的值
object oState = null; // TODO: 初始化为适当的值
DelayStateCallTimer target = new DelayStateCallTimer(processPriority, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, oState); // TODO: 初始化为适当的值
string expected = string.Empty; // TODO: 初始化为适当的值
string actual;
actual = target.ToString();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
/// <summary>
/// 创建一个新的时间片
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="intervalTimeSpan"></param>
/// <param name="count"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, long iCount, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
return(StartTimeSlice(TimerPriority.Normal, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, tState));
}
/// <summary>
/// 创建一个新的时间片
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="intervalTimeSpan"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimerPriority processPriority, TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
return(StartTimeSlice(processPriority, delayTimeSpan, intervalTimeSpan, 0, timerStateCallback, tState));
}
/// <summary>
/// 创建一个新的时间片
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimeSpan delayTimeSpan, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
return(StartTimeSlice(TimerPriority.Normal, delayTimeSpan, TimeSpan.Zero, 1, timerStateCallback, tState));
}
/// <summary>
/// 创建一个新的时间片
/// </summary>
/// <param name="delayTimeSpan"></param>
/// <param name="intervalTimeSpan"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice(TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, TimeSliceStateCallback timerStateCallback, object tState)
{
return(StartTimeSlice(TimerPriority.Normal, delayTimeSpan, intervalTimeSpan, 0, timerStateCallback, tState));
}
/// <summary>
/// 创建一个新的时间片
/// </summary>
/// <param name="delayTimeSpan"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice(TimerPriority processPriority, TimeSpan delayTimeSpan, TimeSliceStateCallback timerStateCallback, object tState)
{
return(StartTimeSlice(processPriority, delayTimeSpan, TimeSpan.Zero, 1, timerStateCallback, tState));
}
/// <summary>
/// 从 delayTimeSpan 后开始，每隔 intervalTimeSpan 调用一次回调函数，直到超过 timeLeft 的时间。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="intervalTimeSpan"></param>
/// <param name="timeLeft"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, TimeSpan timeLeft, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
return(StartTimeSlice(delayTimeSpan, intervalTimeSpan, long.MaxValue, timeLeft, timerStateCallback, tState));
}
/// <summary>
/// 延迟调用的时间有状态类
/// </summary>
/// <param name="iTimes">调用的次数</param>
/// <param name="delayTimeSpan">延迟的时间</param>
/// <param name="intervalTimeSpan">间隔的时间</param>
/// <param name="timerStateCallback">委托</param>
/// <param name="timeLeft">剩余时间</param>
/// <param name="tState">回调的状态类</param>
public DelayStateCallTimer(TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, long iTimes, TimeSpan timeLeft, TimeSliceStateCallback <T> timerStateCallback, T tState)
: base(delayTimeSpan, intervalTimeSpan, iTimes, timeLeft)
{
m_Callback = timerStateCallback;
m_State = tState;
}
/// <summary>
/// 创建一个新的时间片
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="intervalTimeSpan"></param>
/// <param name="count"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimerPriority processPriority, TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, long iCount, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
TimeSlice tTimer = new DelayStateCallTimer <T>(processPriority, delayTimeSpan, intervalTimeSpan, iCount, timerStateCallback, tState);
tTimer.Start();
return(tTimer);
}
/// <summary>
/// 在 delayTimeSpan 时间结束后调用一次回调函数
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimeSpan delayTimeSpan, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
return(StartTimeSlice(delayTimeSpan, TimeSpan.Zero, 1, TimeSpan.MaxValue, timerStateCallback, tState));
}
/// <summary>
/// 延迟调用的时间有状态类
/// </summary>
/// <param name="delayTimeSpan">延迟的时间</param>
/// <param name="intervalTimeSpan">间隔的时间</param>
/// <param name="iCount">调用的次数</param>
/// <param name="timerStateCallback">委托</param>
/// <param name="oState">回调的状态类</param>
public DelayStateCallTimer(TimerPriority processPriority, TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, long iCount, TimeSliceStateCallback timerStateCallback, object oState)
: base(processPriority, delayTimeSpan, intervalTimeSpan, iCount)
{
m_Callback = timerStateCallback;
m_State = oState;
}
/// <summary>
/// 带优先级从 delayTimeSpan 后开始，每隔 intervalTimeSpan 调用一次回调函数，直到超过 timeLeft 的时间或者回调次数达到 iTimes。
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="delayTimeSpan"></param>
/// <param name="intervalTimeSpan"></param>
/// <param name="iTimes"></param>
/// <param name="timeLeft"></param>
/// <param name="timerStateCallback"></param>
/// <param name="tState"></param>
/// <returns></returns>
public static TimeSlice StartTimeSlice <T>(TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, long iTimes, TimeSpan timeLeft, TimeSliceStateCallback <T> timerStateCallback, T tState)
{
TimeSlice timeSlice = new DelayStateCallTimer <T>(delayTimeSpan, intervalTimeSpan, iTimes, timeLeft, timerStateCallback, tState);
timeSlice.Start();
return(timeSlice);
}
/// <summary>
/// 延迟调用的时间有状态类
/// </summary>
/// <param name="delayTimeSpan">延迟的时间</param>
/// <param name="intervalTimeSpan">间隔的时间</param>
/// <param name="iCount">调用的次数</param>
/// <param name="timerStateCallback">委托</param>
/// <param name="oState">回调的状态类</param>
public DelayStateCallTimer( TimerPriority processPriority, TimeSpan delayTimeSpan, TimeSpan intervalTimeSpan, long iCount, TimeSliceStateCallback timerStateCallback, object oState )
: base( processPriority, delayTimeSpan, intervalTimeSpan, iCount )
{
m_Callback = timerStateCallback;
m_State = oState;
}
