CODEWITHSUNDEEP
c#asp.nethttpwebrequesthttphandler
mkelley33
mkelley33

Reputation: 5601

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.

Upvotes: 7

Views: 11487

Answers (5)

J. Random Coder
J. Random Coder

Reputation: 1342

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

Upvotes: 9

Richard Szalay
Richard Szalay

Reputation: 84804

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

Upvotes: 12

Douglas
Douglas

Reputation: 54897

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

Upvotes: 8

Thomas Levesque
Thomas Levesque

Reputation: 292635

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

Upvotes: 1

LorenVS
LorenVS

Reputation: 12867

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

Upvotes: 0

Related Questions