public AssemblyLoader(string path, string entryPointType, string entryPointMethod, string entryPointArg,
bool isPreloading, Runtime.AssemblyContextRef assemblyContextRef)
{
this.entryPointType = entryPointType;
this.entryPointMethod = entryPointMethod;
this.entryPointArg = entryPointArg;
this.assemblyPath = path;
this.isPreloading = isPreloading;
this.assemblyContextRef = assemblyContextRef;
}
private static void UnloadMainContext(bool threaded = true)
{
if (!mainContextRef.IsInvalid)
{
try
{
AssemblyUnloader unloader = new AssemblyUnloader(entryPointType, unloadMethod, mainContextRef);
mainContextRef.DoCallBack(unloader.Unload);
}
catch (Exception e)
{
MessageBox("HotReload Unload failed for \"" + mainAssemblyPath + "\" " +
Environment.NewLine + Environment.NewLine + e, unloadErrorMsgBoxTitle);
}
Runtime.AssemblyContextRef oldContextRef = mainContextRef;
mainContextRef = Runtime.AssemblyContextRef.Invalid;
UnloadContext(oldContextRef, threaded);
}
}
private static void CreatePreloadedContext(string entryPointArg)
{
Runtime.AssemblyContextRef contextRef = Runtime.AssemblyContextRef.Invalid;
if (SharedRuntimeState.CurrentRuntime == EDotNetRuntime.CoreCLR)
{
contextRef = Runtime.AssemblyContext.Create();
}
else
{
// Seperate method to avoid issues with .NET Core
contextRef = CreatePreloadedContextAppDomain(entryPointArg);
}
entryPointArg += "|AssemblyContext=" + contextRef.Format();
if (!contextRef.IsInvalid)
{
Debug.Assert(preloadedContextRef.IsInvalid, "Trying to preload when there is already something preloaded");
try
{
AssemblyLoader loader = new AssemblyLoader(mainAssemblyPath, entryPointType, entryPointMethod, entryPointArg, true, contextRef);
contextRef.DoCallBack(loader.Load);
preloadedContextRef = contextRef;
}
catch (Exception e)
{
GameThreadHelper.Run(delegate() // For stylized message box (as we may not be in the game thread)
{
MessageBox("Failed to create assembly context for \"" + mainAssemblyPath + "\" " +
Environment.NewLine + Environment.NewLine + e, errorMsgBoxTitle);
});
preloadFailed = true;
UnloadContext(contextRef);
}
}
}
public AssemblyUnloader(string entryPointType, string unloadMethod, Runtime.AssemblyContextRef assemblyContextRef)
{
this.entryPointType = entryPointType;
this.unloadMethod = unloadMethod;
this.assemblyContextRef = assemblyContextRef;
}
private static void UnloadContext(Runtime.AssemblyContextRef contextRef, bool threaded = true)
{
if (threaded)
{
// Run the Unload on a seperate thread to avoid waiting for it.
new Thread(delegate()
{
UnloadContext(contextRef, false);
}).Start();
}
else
{
Exception exception = null;
bool unloaded = false;
if (SharedRuntimeState.CurrentRuntime == EDotNetRuntime.CoreCLR)
{
WeakReference weakRef = contextRef.GetWeakReference();
try
{
// Just fire and hope for the best
contextRef.Unload();
unloaded = true;
}
catch (Exception e)
{
exception = e;
}
if (unloaded && weakRef != null)
{
for (int i = 0; i < 15 && weakRef.IsAlive; i++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
if (i > 10)
{
Thread.Sleep(100);
}
}
if (weakRef.IsAlive)
{
exception = new Exception(".NET Core couldn't unload the AssemblyLoadContext. There is likely some global event" +
" which is being bound to. You will crash on the next load due to the state not being cleaned up properly.");
unloaded = false;
}
}
}
else
{
for (int i = 0; i < 3; i++)
{
try
{
contextRef.Unload();
unloaded = true;
break;
}
catch (CannotUnloadAppDomainException e)
{
exception = e;
}
catch (AppDomainUnloadedException e)
{
exception = e;
}
// Give it a little more time and then try again
Thread.Sleep(300);
}
}
if (!unloaded)
{
GameThreadHelper.Run(delegate() // For stylized message box (as we may not be in the game thread)
{
MessageBox("Failed to unload assembly context for \"" + mainAssemblyPath + "\" " +
Environment.NewLine + Environment.NewLine + exception, unloadErrorMsgBoxTitle);
});
}
}
}
private static bool ReloadMainContext(bool threaded = true)
{
if (!GameThreadHelper.IsInGameThread())
{
bool result = false;
GameThreadHelper.Run(delegate { result = ReloadMainContext(); });
return(result);
}
if (!SharedRuntimeState.IsActiveRuntime)
{
return(false);
}
if (!File.Exists(mainAssemblyPath))
{
SharedRuntimeState.SetHotReloadData(null);
return(false);
}
if (!mainContextRef.IsInvalid)
{
UnloadMainContext(threaded);
}
string entryPointArgEx = entryPointArg;
bool firstLoad = preloadContextWaitHandle == null;
if (firstLoad)
{
PreloadNextContext(threaded);
}
else
{
entryPointArgEx += "|Reloading=true";
}
preloadContextWaitHandle.WaitOne(Timeout.Infinite);
preloadContextWaitHandle.Reset();
if (!preloadFailed)
{
Debug.Assert(!preloadedContextRef.IsInvalid, "Preloaded context shouldn't be invalid");
mainContextRef = preloadedContextRef;
preloadedContextRef = Runtime.AssemblyContextRef.Invalid;
entryPointArgEx += "|AssemblyContext=" + mainContextRef.Format();
try
{
AssemblyLoader loader = new AssemblyLoader(mainAssemblyPath, entryPointType, entryPointMethod, entryPointArgEx, false, mainContextRef);
mainContextRef.DoCallBack(loader.Load);
UpdateAssemblyWatchers();
}
catch (Exception e)
{
MessageBox("Failed to create assembly context for \"" + mainAssemblyPath + "\" " +
Environment.NewLine + Environment.NewLine + e, errorMsgBoxTitle);
}
}
PreloadNextContext(threaded);
SharedRuntimeState.SetHotReloadData(null);
return(true);
}
