Programmatically determine if code is running unde

Question

I am not sure this is even possible, but I am hoping for a clue as to determine if the code that is currently executing is running under IIS Express. My best approximation so far, which is incredibly hackish and will certainly fail/break at some point:

bool IsExpress = 
  Request.ServerVariables["SERVER_SOFTWARE"] == "Microsoft-IIS/7.5"
  && Int32.Parse(Request.ServerVariables["INSTANCE_ID"]) > 1000000000;

Certainly there has to be a better way. My examination of the Application, Server and Request objects didn't seem to reveal anything that might provide better insight. Perhaps I just need to look at some other object?

Update:

I am really curious if there is a way to detect this - it is really academic at this point I don't have a burning need to use it. The original question stands. But in the spirit of responding to the comments, specifically I am interested in answering a criticism from another question/answer on this site: How to search the server's MIME map. The criticism is that the posted answer does not work for IIS Express, only traditional IIS instances. IIS Express stores the MIME configuration in the applicationhost.config XML file and I would like to update that answer to provide a way to return that information for IIS Express as well. I could certainly just add some code that grabs the appropriate value from the XML (Yay for LINQ to XML!) but I would really like to make it smarter. To be clear, I don't need help parsing that file - just something more elegant in trying to detect if code is currently executing in the IIS Express engine.

Update 2:

IIS 8.0 Express Beta was released this week, and it further goes to show that the approach in my question is brittle and will break. While it isn't a deal breaker to target a specific version, it would be nice to account for that and try to ensure the code will work with at least the known versions today.

Answer 1

Can we not try and see if one or more limitation of IIS Express works or not, if it works it is not IIS Express. Example IIS Express does not support sharepoint services

Answer 2

Would checking the current process name do the trick?

bool isExpress = 
  String.Compare(Process.GetCurrentProcess().ProcessName,"iisexpress") == 0;

Normal IIS runs under w3wp.exe from memory.

Answer 3

Oran Dennison's answer doesn't work for me any more with dotnet core.

I extended it by first creating a method that can get the parent process:

/// <summary>
/// A utility class to determine a process parent.
/// </summary>
/// <remarks>
/// From https://stackoverflow.com/a/3346055/240845
/// </remarks>
public static class ParentProcessUtilities
{
    /// <summary>
    /// Gets the parent process.
    /// </summary>
    /// <param name="process">The process to get the parent of</param>
    /// <returns>The parent process.</returns>
    public static Process Parent(this Process process)
    {
        return GetParentProcess(process.Handle);
    }

    /// <summary>
    /// Gets the parent process of the current process.
    /// </summary>
    /// <returns>An instance of the Process class.</returns>
    public static Process GetParentProcess()
    {
        return Process.GetCurrentProcess().Parent();
    }

    /// <summary>
    /// Gets the parent process of a specified process.
    /// </summary>
    /// <param name="handle">The process handle.</param>
    /// <returns>The parent process.</returns>
    public static Process GetParentProcess(IntPtr handle)
    {
        ProcessInformation pbi = new ProcessInformation();

        // Note, according to Microsoft, this usage of NtQueryInformationProcess is 
        // unsupported and may change
        int status = NtQueryInformationProcess(
            handle, 0, ref pbi, Marshal.SizeOf(pbi), out _);
        if (status != 0)
        {
            throw new Win32Exception(status);
        }

        try
        {
            return Process.GetProcessById(pbi.InheritedFromUniqueProcessId.ToInt32());
        }
        catch (ArgumentException)
        {
            // not found
            return null;
        }
    }

    [DllImport("ntdll.dll")]
    private static extern int NtQueryInformationProcess(
        IntPtr processHandle, int processInformationClass,
        ref ProcessInformation processInformation, int processInformationLength, 
        out int returnLength);

    /// <summary>
    /// Used in the NtQueryInformationProcess call.
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct ProcessInformation
    {
        // These members must match PROCESS_BASIC_INFORMATION
        internal IntPtr Reserved1;
        internal IntPtr PebBaseAddress;
        internal IntPtr Reserved2_0;
        internal IntPtr Reserved2_1;
        internal IntPtr UniqueProcessId;
        internal IntPtr InheritedFromUniqueProcessId;

    }
}

Then, you can do something like:

public bool IsUnderIisExpress()
{
    var currentProcess = Process.GetCurrentProcess();
    if (string.CompareOrdinal(currentProcess.ProcessName, "iisexpress") == 0)
    {
       return true;
    }

    var parentProcess = currentProcess.Parent();
    if (string.CompareOrdinal(parentProcess.ProcessName, "iisexpress") == 0
        || string.CompareOrdinal(parentProcess.ProcessName, "VSIISExeLauncher") == 0)
    {
        return true;
    }

    return false;
}

Answer 4

If you don't mind dropping into COM level APIs, you could use the IIS Version Manager API

http://msdn.microsoft.com/en-us/library/gg418429.aspx

There is some discussion about how this has been used in this SO Post: Starting and stopping IIS Express programmatically -- not exactly what you want, but they do discuss using the API.

Edit: I should add that I haven't tried this myself but it seems promising, good luck!