How do I get the MIME type of a file being requested in ASP.NET C#?

I would like to handle requests differently depending upon the MIME type. For example, I have PDF’s, images and other media files that I would like to prohibit access to based on their respective MIME types. Any ideas on how to do this? Thanks for the help.

I should also note that accessing the Windows registry is not an option for my application.

Answers:

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

.NET’s mime-type mappings are stored in the System.Web.MimeMapping class which offers the GetMimeMapping method.

Prior to .NET 4.5, this class was marked as internal, and thus not available to your code. In that case the best you can do is steal the list, which you can get using Reflector and decompile the static constructor (cctor).

If taking that approach, you may be better off simply creating a list of supported extensions and their mime type and storing it on a dictionary. (The list inside MimeMapping is a tad verbose)

Method 2

I had a similar problem a few month ago and solved it with this simple wrapper-class around System.Web.MimeMapping (as mentioned by Richard Szalay):

/// <summary>
/// This class allows access to the internal MimeMapping-Class in System.Web
/// </summary>
class MimeMappingWrapper
{
    static MethodInfo getMimeMappingMethod;

    static MimeMappingWrapper() {
        // dirty trick - Assembly.LoadWIthPartialName has been deprecated
        Assembly ass = Assembly.LoadWithPartialName("System.Web");
        Type t = ass.GetType("System.Web.MimeMapping");

        getMimeMappingMethod = t.GetMethod("GetMimeMapping", BindingFlags.Static | BindingFlags.NonPublic);
    }

    /// <summary>
    /// Returns a MIME type depending on the passed files extension
    /// </summary>
    /// <param name="fileName">File to get a MIME type for</param>
    /// <returns>MIME type according to the files extension</returns>
    public static string GetMimeMapping(string fileName) {
        return (string)getMimeMappingMethod.Invoke(null, new[] { fileName });
    }
}

Method 3

Cross-posting from Why would Reflection search suddenly not find anything?

The good news is that the MimeMapping class and its GetMimeMapping method seem like they might be made public in .NET 4.5.

However, this means that the code given in the above answer would break, since it’s only searching for GetMimeMapping among NonPublic methods.

To ensure compatibility with .NET 4.5 (but preserve functionality in .NET 4.0 and earlier), change…

getMimeMappingMethod = t.GetMethod("GetMimeMapping", 
    BindingFlags.Static | BindingFlags.NonPublic);

…to:

getMimeMappingMethod = t.GetMethod("GetMimeMapping",
    BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);

Method 4

This information is in the registry, in HKEY_CLASSES_ROOT<file_extension>Content Type

using(var key = Registry.ClassesRoot.OpenSubKey(".htm"))
{
    string mimeType = key.GetValue("Content Type") as string;
}

Method 5

If I am understanding your question properly, you are serving static files and want to be able to do processing on a static file request in order to decide whether or not the user has access to that file. (based on MIME type)

If you map all files requests through a custom IHttpHandler (see the handlers section of your web.config file), you should be able to accomplish this.

In ProcessRequest (or BeginProcessRequest if you implement an asynchronous handler), you can call HttpContext.Current.Server.MapPath(“~” + HttpContext.Current.Request.Path) (might be a better way to do that) to get the current static file being requested.

You can then analyze the extension of that file to make your decision.

Not sure if thats what you want, but hopefully it helps

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0