public void Initialize(
string settingsFileName,
string testSubdirectory)
{
if (settingsFileName == null)
{
throw new ArgumentNullException(nameof(settingsFileName));
}
if (testSubdirectory == null)
{
throw new ArgumentNullException(nameof(testSubdirectory));
}
_dataDirectory = Path.Combine(
Path.GetTempPath(),
"PVDevelop",
"ReminderBot",
"Commander",
"Tests",
testSubdirectory);
ClearDataDirectory();
_application =
new ApplicationBuilder(configurationPath: AppContext.BaseDirectory).
WithJsonSettings(jsonSettingsFileName: settingsFileName).
Build();
}
/// <summary>注销轮循线程
/// Uns the register intervalu object.
/// </summary>
/// <param name="runnable">The runnable.</param>
public static void UnRegisterIntervaluObject(IRunable runnable)
{
if (runnable.RegisterdHandler != null && runnable.WaitHandler != null)
{
runnable.RegisterdHandler.Unregister(runnable.WaitHandler);
}
}
public void UseCar()
{
carenum carenum = (carenum)(Enum.Parse(typeof(carenum), cartype));
IRunable runable = null;
switch (carenum)
{
case carenum.aodi:
runable = new Aodi();
break;
case carenum.baoma:
runable = new BaoMa();
break;
case carenum.benchi:
runable = new Benchi();
break;
default:
break;
}
runable.GuaDang();
runable.Run();
}
public INameManager Register(IRunable runable)
{
var page = runable as IPage;
if (page != null)
{
if (string.IsNullOrEmpty(page.Name))
{
page.Name = Guid.NewGuid().ToShortString();
}
Pages.Add(page.Name, page);
}
var service = runable as IService;
if (service != null)
{
if (string.IsNullOrEmpty(service.Name))
{
service.Name = Guid.NewGuid().ToShortString();
}
Services.Add(service.Name, service);
}
return(this);
}
public void Register(IRunable runable)
{
var page = runable as IPage;
if (page != null)
{
if (string.IsNullOrEmpty(page.Name))
{
page.Name = GenerateElementName(page.Package);
}
else
{
ValidateName(page.Name, page.Package);
}
lock (_pages) _pages.Add(page.Name, page);
}
var service = runable as IService;
if (service != null)
{
if (string.IsNullOrEmpty(service.Name))
{
service.Name = GenerateElementName(service.Package);
}
else
{
ValidateName(service.Name, service.Package);
}
lock (_services) _services.Add(service.Name, service);
}
}
/// <summary>注销轮循线程
/// Uns the register intervalu object.
/// </summary>
/// <param name="runnable">The runnable.</param>
public static void UnRegisterIntervaluObject(IRunable runnable)
{
if (runnable.RegisterdHandler != null && runnable.WaitHandler != null)
{
runnable.RegisterdHandler.Unregister(runnable.WaitHandler);
}
}
public INameManager RegisterRunable(IRunable runable)
{
var name = runable.Package == null
? runable.Name
: runable.Package.NamespaceName + ":" + runable.Name;
try
{
var page = runable as IPage;
if (page != null)
{
lock (_pages) _pages.Add(name, page);
}
var service = runable as IService;
if (service != null)
{
lock (_services) _services.Add(name, service);
}
}
catch (Exception ex)
{
throw new NameManagerException("Failed to register runable name '" + name + "' as " + runable, ex);
}
return(this);
}
private void RunTask()
{
while (true)
{
IRunable t = null;
lock (this)
{
if (tasks.Count > 0)
{
t = tasks[0];
tasks.RemoveAt(0);
}
}
if (t != null)
{
currentTask = t;
t.Run();
currentTask = null;
TipsCenter.Ins.BackTaskInf = ToString();
}
else
{
System.Threading.Thread.Sleep(2000);
}
}
}
public INameManager Register(IRunable runable)
{
if (string.IsNullOrEmpty(runable.Name))
{
runable.Name = GenerateElementName(runable.Package);
if (_debugLogging)
{
Trace.WriteLine("Name manager assigned '" + runable.Name +
"' to anonymous " + runable.ElementType + " of type " +
runable.GetType().DisplayName());
}
}
else
{
ValidateElementName(runable.Name, runable.Package);
}
if (runable.Package == null)
{
_pendingRunableRegistrations.Add(runable);
}
else
{
RegisterRunable(runable);
}
return(this);
}
/// <summary>
/// 注册一个轮循线程
/// <remark>abu 2008-03-07 </remark>
/// </summary>
/// <param name="runnable">The runnable.</param>
/// <param name="state">The state.</param>
/// <param name="interval">The interval.</param>
public static void RegisterIntervalObject(IRunable runnable, object state, long interval, bool onlyOnce)
{
// if (runnable.RegisterdHandler == null)
// {
runnable.WaitHandler = new AutoResetEvent(false);
runnable.RegisterdHandler = ThreadPool.RegisterWaitForSingleObject(runnable.WaitHandler, new WaitOrTimerCallback(runnable.Run), state, interval, onlyOnce);
// }
}
private void OnEnable()
{
_selfTransform = GetComponent <Transform>();
_loadLine = GetComponentInChildren <IRunable <float> >();
var spawnTime = Instantiate(_spawnTimeViewer, FindObjectOfType <SpawnTimeParent>().transform);
_spawnTimeViewer = spawnTime.GetComponent <SpawnTimeViewer>();
}
/// <summary>
/// 注册一个轮循线程
/// </summary>
/// <param name="runnable">The runnable.</param>
/// <param name="state">The state.</param>
/// <param name="interval">The interval.</param>
public static void RegisterIntervalObject(IRunable runnable, object state, long interval, bool onlyOnce)
{
// if (runnable.RegisterdHandler == null)
// {
runnable.WaitHandler = new AutoResetEvent(false);
runnable.RegisterdHandler = ThreadPool.RegisterWaitForSingleObject(runnable.WaitHandler, new WaitOrTimerCallback(runnable.Run), state, interval, onlyOnce);
// }
}
public IDisposable Register(IRunable runable, IRequestFilter filter, int priority, Type declaringType)
{
Runable = runable;
Filter = filter;
Priority = priority;
DeclaringType = declaringType;
return(this);
}
public void Add(IRunable t)
{
lock (this)
{
ins.tasks.Add(t);
TipsCenter.Ins.BackTaskInf = ToString();
}
}
private static string AssertionMessage(IRunable Object, int miliseconds, string name)
{
string AssertionName;
if (name == "")
AssertionName=Object.ObjectsName()+".Run()";
else
AssertionName=name;
return AssertionName + " has exceeded " + miliseconds + " miliseconds.";
}
public IDisposable Register(IRunable runable, IRequestFilter filter, int priority, Type declaringType, string scenarioName)
{
Runable = runable;
Filter = filter;
Priority = priority;
DeclaringType = declaringType;
UserSegmentKey = scenarioName;
return(this);
}
public IDisposable Register(IRunable runable, IRequestFilter filter, int priority, MethodInfo methodInfo, string scenarioName)
{
Runable = runable;
Filter = filter;
Priority = priority;
MethodInfo = methodInfo;
UserSegmentKey = scenarioName;
return(this);
}
/// <summary>
/// Starts with specified config.
/// </summary>
/// <param name="config">The config.</param>
/// <returns></returns>
public static bool Start(IConfig config)
{
List <IServerConfig> serverList = config.GetServerList();
Type serviceType = null;
//ServiceCredentials credentials = null;
//if (config.CredentialConfig != null)
// credentials = GetServiceCredentials(config.CredentialConfig);
foreach (IServerConfig serverConfig in serverList)
{
if (serverConfig.Disabled)
{
continue;
}
bool startResult = false;
if (m_ServiceDict.TryGetValue(serverConfig.ServiceName, out serviceType))
{
if (serviceType == null)
{
LogUtil.LogError(string.Format("The service {0} cannot be found in configuration!", serverConfig.ServiceName));
LogUtil.LogError("Failed to start " + serverConfig.Name + " server!");
return(false);
}
IRunable server = Activator.CreateInstance(serviceType) as IRunable;
if (server != null && server.Setup(GetServiceProvider(serverConfig.ServiceName, serverConfig.Provider), serverConfig, config.ConsoleBaseAddress))
{
//server.ServerCredentials = credentials;
if (server.Start())
{
m_ServerList.Add(server);
startResult = true;
}
}
}
if (!startResult)
{
LogUtil.LogError("Failed to start " + serverConfig.Name + " server!");
return(false);
}
else
{
LogUtil.LogInfo(serverConfig.Name + " has been started");
}
}
return(true);
}
internal static void Assertion(IRunable Object, int miliseconds, string name="")
{
try
{
RunWithTimeout(Object, miliseconds);
}
catch (AutOfTimeException e)
{
string message = AssertionMessage(Object, miliseconds, name);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.Fail(message);
}
}
private IEnumerator SpawnObjects()
{
while (IsUsing)
{
_runablePool.GetObject().LeaveThePool(_selfTransform.position);
if (_loadLine == null)
{
_loadLine = GetComponentInChildren <IRunable <float> >();
}
_loadLine.Run(SpawnTime);
yield return(new WaitForSeconds(SpawnTime));
}
}
private void Configure(AttributeSet attributes, IRunable runable)
{
if (runable == null)
{
return;
}
if (attributes.RequiresPermission != null)
{
runable.RequiredPermission = attributes.RequiresPermission.PermissionName;
}
if (attributes.CacheOutput != null)
{
runable.CacheCategory = attributes.CacheOutput.CacheCategory;
runable.CachePriority = attributes.CacheOutput.CachePriority;
}
if (attributes.Routes != null)
{
foreach (var route in attributes.Routes)
{
if (route.Methods == null || route.Methods.Length == 0)
{
if (string.IsNullOrEmpty(route.Path))
{
continue;
}
_requestRouter.Register(runable, new FilterByPath(route.Path), route.Priority, attributes.Type);
}
else
{
if (string.IsNullOrEmpty(route.Path))
{
_requestRouter.Register(runable, new FilterByMethod(route.Methods), route.Priority);
}
else
{
_requestRouter.Register(
runable,
new FilterAllFilters(
new FilterByMethod(route.Methods),
new FilterByPath(route.Path)),
route.Priority,
attributes.Type);
}
}
}
}
}
IDisposable IRequestRouter.Register(
IRunable runable,
IRequestFilter filter,
int priority,
Type declaringType,
string scenarioName)
{
return(Add(new Registration
{
Priority = priority,
Filter = filter,
TestScenarioName = string.IsNullOrWhiteSpace(scenarioName) ? null : scenarioName,
Runable = runable,
DeclaringType = declaringType ?? runable.GetType()
}));
}
IDisposable IRequestRouter.Register(IRunable runable, IRequestFilter filter, int priority, Type declaringType)
{
var registration = new Registration
{
Priority = priority,
Filter = filter,
Runable = runable,
DeclaringType = declaringType ?? runable.GetType()
};
lock (_registrations)
{
_registrations.Add(registration);
_registrations.Sort();
}
return(registration);
}
/// <summary>
/// Starts the available IRunables from the [PluginsFolder] folder
/// </summary>
/// <returns></returns>
public void Start()
{
lock (_lockObj)
{
if (!Initialized)
{
_logger.Error($"{nameof(PluginLoader)} not initialized yet.");
return;
}
if (_iRunables.Count > 1)
{
_logger.Error($"More {nameof(IRunable)} was found in folder: {PluginsFolder}");
foreach (KeyValuePair <Type, Assembly> item in _iRunables)
{
_logger.Info($"{nameof(IRunable)} was found in type {item.Key} in assembly: {item.Value}");
}
return;
}
try
{
Type type = _iRunables[0].Key;
IRunable runable = (IRunable)Activator.CreateInstance(type);
_logger.Info($"{nameof(IRunable)} was created with the type: {type}");
runable.Run();
_logger.Info($"{type} started.");
}
catch (Exception ex)
{
SendToErrorLogAndConsole($"Exception occured: {ex}");
}
}
}
/// <summary>
/// 简单工厂-基础实现r
/// </summary>
/// <param name="carenum"></param>
public void UseCar(carenum carenum)
{
IRunable runable = null;
switch (carenum)
{
case carenum.aodi:
runable = new Aodi();
break;
case carenum.baoma:
runable = new BaoMa();
break;
case carenum.benchi:
runable = new Benchi();
break;
default:
break;
}
runable.GuaDang();
runable.Run();
}
public void Add(IRunable runable)
{
lst.Add(runable);
}
public void Remove(IRunable runable)
{
lst.Remove(runable);
}
static void Run(IRunable runnable)
{
runnable.Run();
}
static void Running(IRunable runner) //인터페이스에 정의된 클래스 타입으로 자식클래스 사용(부모↔ 자식 자동 형변환)
{
runner.Run();
}
/// <summary> Advanced: start runnable object in local thread, and return thread instance </summary>
public static void Run(IRunable runnable, out Thread worker)
{
worker = new Thread(delegate(object runObj) { ((IRunable)runObj).Run(); });
worker.Start();
}
/// <summary> Start runnable object in ThreadPool </summary>
public static void Run(IRunable runnable)
{
WaitCallback callback = new WaitCallback(delegate(object runObj) { ((IRunable)runObj).Run(); });
ThreadPool.QueueUserWorkItem(callback, runnable);
}
public GameRunner(IRunable run)
{
this.run = run;
}
public static void Post(IRunable task)
{
ThreadPool.QueueUserWorkItem(task.Run);
}
static void Running(IRunable runner)
{
runner.Run();
}
public static void RunWithTimeout(IRunable obj, int timeOutForThread)
{
RunWithTimeout(obj.Run, timeOutForThread);
}
