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

Question

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 ba

Answer 1

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;
}

Answer 2

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

Answer 3

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 });
    }
}

Answer 4

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);

Answer 5

.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)