public static void Tick()
{
var flowBlock = CitizenTaskScheduler.SuppressFlow();
Action[] tasks;
lock (m_scheduledTasks)
{
tasks = m_scheduledTasks.ToArray();
m_scheduledTasks.Clear();
}
foreach (var task in tasks)
{
try
{
task();
}
catch (Exception e)
{
Debug.WriteLine($"Exception during executing Post callback: {e}");
}
}
flowBlock?.Undo();
}
public static void Initialize()
{
InitializeResourceInfo();
Debug.WriteLine("Initializing Mono script environment for {0}.", ms_resourceName);
try
{
// set the assembly resolver
InitializeAssemblyResolver();
// configure the task scheduler
CitizenTaskScheduler.Create();
ms_definedScripts.Add(new TestScript());
}
catch (Exception e)
{
Debug.WriteLine("Fatal error during loading: {0}", e.ToString());
if (e.InnerException != null)
{
Debug.WriteLine("{0}", e.InnerException.ToString());
}
throw e;
}
}
public static void Tick()
{
var flowBlock = CitizenTaskScheduler.SuppressFlow();
try
{
Action[] tasks;
lock (m_scheduledTasks)
{
tasks = m_scheduledTasks.ToArray();
m_scheduledTasks.Clear();
}
foreach (var task in tasks)
{
try
{
task();
}
catch (Exception e)
{
InternalManager.PrintErrorInternal($"task continuation", e);
}
}
}
finally
{
}
flowBlock?.Undo();
}
public void CreateTaskScheduler()
{
CitizenTaskScheduler.MakeDefault();
#if !IS_FXSERVER
SynchronizationContext.SetSynchronizationContext(new CitizenSynchronizationContext());
#endif
}
public static void Create()
{
Instance = new CitizenTaskScheduler();
Factory = new TaskFactory(Instance);
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
}
public InternalManager()
{
//CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
//CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
InitializeAssemblyResolver();
CitizenTaskScheduler.Create();
SynchronizationContext.SetSynchronizationContext(new CitizenSynchronizationContext());
}
public InternalManager()
{
//CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
//CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
GlobalManager = this;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;
InitializeAssemblyResolver();
CitizenTaskScheduler.Create();
}
public static void Create()
{
Instance = new CitizenTaskScheduler();
Factory = new TaskFactory(Instance);
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
var field = typeof(TaskScheduler).GetField("s_defaultTaskScheduler", BindingFlags.Static | BindingFlags.NonPublic);
field.SetValue(null, Instance);
field = typeof(Task).GetField("s_factory", BindingFlags.Static | BindingFlags.NonPublic);
field.SetValue(null, Factory);
}
public static void Create()
{
Instance = new CitizenTaskScheduler();
Factory = new TaskFactory(Instance);
}
public InternalManager()
{
InitializeAssemblyResolver();
CitizenTaskScheduler.Create();
}
public void Tick()
{
IsProfiling = ProfilerIsRecording();
if (GameInterface.SnapshotStackBoundary(out var b))
{
ScriptHost.SubmitBoundaryStart(b, b.Length);
}
try
{
using (var scope = new ProfilerScope(() => "c# cleanup"))
{
ScriptContext.GlobalCleanUp();
}
using (var scope = new ProfilerScope(() => "c# deferredDelay"))
{
var now = DateTime.UtcNow;
var count = ms_delays.Count;
for (int delayIdx = 0; delayIdx < count; delayIdx++)
{
var delay = ms_delays[delayIdx];
if (now >= delay.Item1)
{
using (var inScope = new ProfilerScope(() => delay.Item3))
{
try
{
BaseScript.CurrentName = delay.Item3;
delay.Item2(new DummyAsyncResult());
}
finally
{
BaseScript.CurrentName = null;
}
}
ms_delays.RemoveAt(delayIdx);
delayIdx--;
count--;
}
}
}
using (var scope = new ProfilerScope(() => "c# schedule"))
{
var flowBlock = CitizenTaskScheduler.SuppressFlow();
foreach (var script in ms_definedScripts.ToArray())
{
script.ScheduleRun();
}
flowBlock?.Undo();
}
using (var scope = new ProfilerScope(() => "c# tasks"))
{
CitizenTaskScheduler.Instance.Tick();
}
using (var scope = new ProfilerScope(() => "c# syncCtx"))
{
CitizenSynchronizationContext.Tick();
}
}
catch (Exception e)
{
PrintError("tick", e);
}
finally
{
ScriptHost.SubmitBoundaryStart(null, 0);
}
}
public static void Initialize()
{
Debug.WriteLine("Hello!");
CitizenTaskScheduler.Create();
}
public static void Initialize()
{
CitizenTaskScheduler.Create();
}
