public static void SetPreAppStartStage() {
var stage = typeof(BuildManager).GetProperty("PreStartInitStage", BindingFlags.Static | BindingFlags.NonPublic);
var value = ((FieldInfo)typeof(BuildManager).Assembly.GetType("System.Web.Compilation.PreStartInitStage").GetMember("DuringPreStartInit")[0]).GetValue(null);
stage.SetValue(null, value, new object[] { });
SetAppData();
var env = new HostingEnvironment();
}
public HostingEnvironment()
{
if (_theHostingEnvironment != null)
{
throw new InvalidOperationException(System.Web.SR.GetString("Only_1_HostEnv"));
}
_theHostingEnvironment = this;
this._onAppDomainUnload = new EventHandler(this.OnAppDomainUnload);
Thread.GetDomain().DomainUnload += this._onAppDomainUnload;
}
//private readonly object _fileChangesManager;
//private readonly FieldInfo _callbackFieldInfo;
//private readonly FieldInfo _isFCNDisabledFieldInfo;
//private readonly object _savedCallbackValue;
/// <exclude />
public ShutdownGuard()
{
if (!HostingEnvironment.IsHosted)
{
return;
}
const BindingFlags getStaticFieldValue = BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.GetField;
_runtime = (HttpRuntime)typeof(HttpRuntime).InvokeMember("_theRuntime", getStaticFieldValue, null, null, null);
_hostingEnvironment = (HostingEnvironment)typeof(HostingEnvironment).InvokeMember("_theHostingEnvironment", getStaticFieldValue, null, null, null);
const BindingFlags privateField = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetField;
_shutdownWebEventRaised_FieldInfo = typeof(HttpRuntime).GetField("_shutdownWebEventRaised", privateField);
// In .NET 3.5 the field is called "_shutdownInitated"
// .NET 4.0 the field is called "_shutdownInitiated"
_shutdownInitiated_FieldInfo = typeof(HostingEnvironment).GetField("_shutdownInitiated", privateField)
?? typeof(HostingEnvironment).GetField("_shutdownInitated", privateField);
// Simulating situation, when all events to unload current AppDomain were already raised.
_shutdownWebEventRaised_FieldInfo.SetValue(_runtime, true);
_shutdownInitiated_FieldInfo.SetValue(_hostingEnvironment, true);
//_fileChangesManager = runtime.GetType().GetField("_fcm", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.GetField).GetValue(runtime);
//_callbackFieldInfo = _fileChangesManager.GetType().GetField("_callbackRenameOrCriticaldirChange",
// BindingFlags.NonPublic |
// BindingFlags.Instance |
// BindingFlags.GetField);
//_isFCNDisabledFieldInfo = _fileChangesManager.GetType().GetField("_FCNMode",
// BindingFlags.NonPublic |
// BindingFlags.Instance |
// BindingFlags.GetField);
//_savedCallbackValue = _callbackFieldInfo.GetValue(_fileChangesManager);
//_callbackFieldInfo.SetValue(_fileChangesManager, null);
//// Turning off file change notifications. http://support.microsoft.com/kb/911272
//_isFCNDisabledFieldInfo.SetValue(_fileChangesManager, (Int32)1);
}
protected static HostingEnvironment GetHostingEnvironment()
{
HostingEnvironment environment;
try
{
environment = new HostingEnvironment();
}
catch (InvalidOperationException)
{
//Shoot, we need to grab it via reflection.
environment = ReflectionHelper.GetStaticFieldValue<HostingEnvironment>("_theHostingEnvironment", typeof(HostingEnvironment));
}
return environment;
}
public static void SetupVirtualPathInAppDomain(string vpath, string contents)
{
var file = new Mock<VirtualFile>(vpath);
file.Setup(f => f.Open()).Returns(new MemoryStream(ASCIIEncoding.Default.GetBytes(contents)));
var vpp = new Mock<VirtualPathProvider>();
vpp.Setup(p => p.FileExists(vpath)).Returns(true);
vpp.Setup(p => p.GetFile(vpath)).Returns(file.Object);
AppDomainUtils.SetAppData();
var env = new HostingEnvironment();
var register = typeof(HostingEnvironment).GetMethod("RegisterVirtualPathProviderInternal", BindingFlags.Static | BindingFlags.NonPublic);
register.Invoke(null, new object[] { vpp.Object });
}
public HostingEnvironment() {
if (_theHostingEnvironment != null)
throw new InvalidOperationException(SR.GetString(SR.Only_1_HostEnv));
// remember singleton HostingEnvironment in a static
_theHostingEnvironment = this;
// start watching for app domain unloading
_onAppDomainUnload = new EventHandler(OnAppDomainUnload);
Thread.GetDomain().DomainUnload += _onAppDomainUnload;
}
public HostingEnvironment() {
if (_theHostingEnvironment != null)
throw new InvalidOperationException(SR.GetString(SR.Only_1_HostEnv));
// remember singleton HostingEnvironment in a static
_theHostingEnvironment = this;
// start watching for app domain unloading
_onAppDomainUnload = new EventHandler(OnAppDomainUnload);
Thread.GetDomain().DomainUnload += _onAppDomainUnload;
// VSO 160528: We used to listen to the default AppDomain's UnhandledException only.
// However, non-serializable exceptions cannot be passed to the default domain. Therefore
// we should try to log exceptions in application AppDomains.
Thread.GetDomain().UnhandledException += new UnhandledExceptionEventHandler(ApplicationManager.OnUnhandledException);
}
private HostingEnvironmentWrapper(object stub)
{
_Inner = new HostingEnvironment();
Configure();
}
internal void HostingEnvironmentShutdownInitiated(string appId, HostingEnvironment env)
{
if (!this._shutdownInProgress)
{
LockableAppDomainContext lockableAppDomainContext = this.GetLockableAppDomainContext(appId);
lock (lockableAppDomainContext)
{
if (!env.HasBeenRemovedFromAppManagerTable)
{
env.HasBeenRemovedFromAppManagerTable = true;
lockableAppDomainContext.HostEnv = null;
Interlocked.Decrement(ref this._accessibleHostingEnvCount);
if ((lockableAppDomainContext.PreloadContext != null) && !lockableAppDomainContext.RetryingPreload)
{
ProcessHost.PreloadApplicationIfNotShuttingdown(appId, lockableAppDomainContext);
}
}
}
}
}
public void FileExistsTest() {
AppDomainUtils.RunInSeparateAppDomain(() => {
var env = new HostingEnvironment();
AppDomainUtils.SetAppData();
var vpp = new Mock<VirtualPathProvider>();
var vpath1 = "/website1/default.cshtml";
var vpath2 = "/website2/default.cshtml";
vpp.Setup(p => p.FileExists(vpath1)).Returns(true).Verifiable();
vpp.Setup(p => p.FileExists(vpath2)).Returns(false).Verifiable();
var register = typeof(HostingEnvironment).GetMethod("RegisterVirtualPathProviderInternal", BindingFlags.Static | BindingFlags.NonPublic);
register.Invoke(null, new object[] { vpp.Object });
var initPage = new Mock<StartPage>().Object;
Assert.IsTrue(initPage.FileExists(vpath1));
Assert.IsFalse(initPage.FileExists(vpath2));
vpp.Verify();
});
}
private void InitHostingEnvironment()
{
try
{
var env = new HostingEnvironment();
var type = env.GetType();
var init = type
.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
.FirstOrDefault(m => m.Name == "Initialize");
var args = new object[init.GetParameters().Length];
args[0] = ApplicationManager.GetApplicationManager();
args[1] = this;
args[2] = GetConfigMapPathFactory();
init.Invoke(env, args);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private void InitHostingEnvironment()
{
try
{
// very hacky way to initialize ASP.NET runtime inside same app domain
var appSettings = ConfigurationManager.AppSettings;
Debug.Assert(appSettings != null);
var cfg = typeof(ConfigurationManager).GetStaticField("s_configSystem");
var env = new HostingEnvironment();
var configSystem = env.GetType().Assembly.GetType("System.Web.Configuration.HttpConfigurationSystem", false);
var cfgsys = cfg.GetField("_configSystem");
configSystem.SetStaticField("s_configSystem", cfgsys);
configSystem.SetStaticField("s_configRoot", cfgsys.GetField("_configRoot"));
configSystem.SetStaticField("s_inited", true);
var type = env.GetType();
var init = type
.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
.FirstOrDefault(m => m.Name == "Initialize");
var args = (from p in init.GetParameters() select GetDefaultValue(p.ParameterType)).ToArray();
args[0] = ApplicationManager.GetApplicationManager();
args[1] = this;
args[2] = GetConfigMapPathFactory();
init.Invoke(env, args);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
