.NET中的文件扩展名和MIME类型

I want to get a MIME Content-Type from a given extension (preferably without accessing the physical file). I have seen some questions about this and the methods described to perform this can be resumed in:

我希望从给定的扩展名(最好不访问物理文件)获得MIME内容类型。我看到了一些关于这方面的问题，可以在以下内容中继续说明执行这方面的方法:

1. Use registry information.
2. 使用注册表信息。
3. Use urlmon.dll's FindMimeFromData.
4. 使用urlmon。dll FindMimeFromData。
5. Use IIS information.
6. 使用IIS信息。
7. Roll your own MIME mapping function. Based on this table, for example.
8. 滚动自己的MIME映射函数。例如，基于这个表。

I've been using no.1 for some time but I realized that the information provided by the registry is not consistent and depends on the software installed on the machine. Some extensions, like .zip don't use to have a Content-Type specified.

我一直在使用。有一段时间，我意识到注册中心提供的信息不一致，依赖于机器上安装的软件。有些扩展，比如.zip，不需要指定内容类型。

Solution no.2 forces me to have the file on disk in order to read the first bytes, which is something slow but may get good results.

没有解决方案。2迫使我将文件放在磁盘上以便读取第一个字节，这是一件很慢的事情，但是可能会得到很好的结果。

The third method is based on Directory Services and all that stuff, which is something I don't like much because I have to add COM references and I'm not sure it's consistent between IIS6 and IIS7. Also, I don't know the performance of this method.

第三种方法基于目录服务之类的东西，这是我不太喜欢的东西，因为我必须添加COM引用，我不确定IIS6和IIS7之间是否一致。另外，我不知道这个方法的性能。

Finally, I didn't want to use my own table but at the end seems the best option if I want a decent performance and consistency of the results between platforms (even Mono).

最后，我不想使用我自己的表，但是如果我想要平台之间的良好性能和结果的一致性(即使是Mono)，最后似乎是最好的选择。

Do you think there's a better option than using my own table or one of other described methods are better? What's your experience?

你认为有比使用我自己的表或其他描述的方法更好的选择吗?你的经验是什么?

6 个解决方案

#1

It depends what you need the MIME type for. In general, for services (web apps, web service, etc.), it's advisable not to use a MIME list which is dependent on the OS settings, or only as fallback if you cannot find MIME information otherwise.

这取决于您需要什么MIME类型。一般来说，对于服务(web应用程序、web服务等)，建议不要使用依赖于操作系统设置的MIME列表，或者只在无法找到MIME信息时使用。

I think that this is also the reason why MS chose to put constant MIME types in their System.Web.MimeMapping class (unfortunately it's internal, for whatever reason).

我认为这也是为什么MS选择在他们的System.Web中加入常量MIME类型的原因。MimeMapping类(不幸的是它是内部的，不管出于什么原因)。

Edit:

编辑:

Wrapper (<= .NET 3.5)

public static class MimeExtensionHelper
{
    static object locker = new object();
    static object mimeMapping;
    static MethodInfo getMimeMappingMethodInfo;

    static MimeExtensionHelper()
    {
        Type mimeMappingType = Assembly.GetAssembly(typeof(HttpRuntime)).GetType("System.Web.MimeMapping");
        if (mimeMappingType == null)
            throw new SystemException("Couldnt find MimeMapping type");
        ConstructorInfo constructorInfo = mimeMappingType.GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
        if (constructorInfo == null)
            throw new SystemException("Couldnt find default constructor for MimeMapping");
        mimeMapping = constructorInfo.Invoke(null);
        if (mimeMapping == null)
            throw new SystemException("Couldnt find MimeMapping");
        getMimeMappingMethodInfo = mimeMappingType.GetMethod("GetMimeMapping", BindingFlags.Static | BindingFlags.NonPublic);
        if (getMimeMappingMethodInfo == null)
            throw new SystemException("Couldnt find GetMimeMapping method");
        if (getMimeMappingMethodInfo.ReturnType != typeof(string))
            throw new SystemException("GetMimeMapping method has invalid return type");
        if (getMimeMappingMethodInfo.GetParameters().Length != 1 && getMimeMappingMethodInfo.GetParameters()[0].ParameterType != typeof(string))
            throw new SystemException("GetMimeMapping method has invalid parameters");
    }
    public static string GetMimeType(string filename)
    {
        lock (locker)
            return (string)getMimeMappingMethodInfo.Invoke(mimeMapping, new object[] { filename });
    }
}

Wrapper (.NET 4.0)

public static class MimeExtensionHelper
    {
        static object locker = new object();
        static object mimeMapping;
        static MethodInfo getMimeMappingMethodInfo;

        static MimeExtensionHelper()
        {
            Type mimeMappingType = Assembly.GetAssembly(typeof(HttpRuntime)).GetType("System.Web.MimeMapping");
            if (mimeMappingType == null)
                throw new SystemException("Couldnt find MimeMapping type");            
            getMimeMappingMethodInfo = mimeMappingType.GetMethod("GetMimeMapping", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
            if (getMimeMappingMethodInfo == null)
                throw new SystemException("Couldnt find GetMimeMapping method");
            if (getMimeMappingMethodInfo.ReturnType != typeof(string))
                throw new SystemException("GetMimeMapping method has invalid return type");
            if (getMimeMappingMethodInfo.GetParameters().Length != 1 && getMimeMappingMethodInfo.GetParameters()[0].ParameterType != typeof(string))
                throw new SystemException("GetMimeMapping method has invalid parameters");
        }
        public static string GetMimeType(string filename)
        {
            lock (locker)
                return (string)getMimeMappingMethodInfo.Invoke(mimeMapping, new object[] { filename });
        }
    }

.NET 4.5+

net 4.5 +

No wrapper required, call the public method System.Web.MimeMapping.GetMimeMapping directly.

不需要包装器，调用公共方法System.Web.MimeMapping。直接GetMimeMapping。

#2

I have combined all these approaches in my utility lib, except maybe no.3. Btw, no.2 (urlmon.dll) doesn't require static file, it simply takes some bytes no matter where they had come from. Here's my current class

我在我的实用程序库中合并了所有这些方法，除了第三种。顺便说一句,没有。2 (urlmon.dll)不需要静态文件，它只需要一些字节，不管它们来自哪里。这是我的当前类

namespace Components
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Xml.Serialization;
    using Microsoft.Win32;

    public sealed class MimeExtensionHelper
    {
        private MimeExtensionHelper() { }

        /// <summary>Finds extension associated with specified mime type</summary>
        /// <param name="mimeType">mime type you search extension for, e.g.: "application/octet-stream"</param>
        /// <returns>most used extension, associated with provided type, e.g.: ".bin"</returns>
        public static string FindExtension(string mimeType)
        {
            return ExtensionTypes.GetExtension(mimeType);
        }

        /// <summary>Finds mime type using provided extension and/or file's binary content.</summary>
        /// <param name="file">Full file path</param>
        /// <param name="verifyFromContent">Should the file's content be examined to verify founded value.</param>
        /// <returns>mime type of file, e.g.: "application/octet-stream"</returns>
        public static string FindMime(string file,bool verifyFromContent)
        {
            string extension = Path.GetExtension(file);
            string mimeType = string.Empty;
            try
            {
                if (!String.IsNullOrEmpty(extension))
                    mimeType = ExtensionTypes.GetMimeType(extension);
                if (verifyFromContent
                    || (String.IsNullOrEmpty(mimeType) && File.Exists(file)))
                    mimeType = FindMimeByContent(file,mimeType);
            }
            catch { }
            return (mimeType ?? string.Empty).Trim();//"application/octet-stream"
        }

        /// <summary>Finds mime type for file using it's binary data.</summary>
        /// <param name="file">Full path to file.</param>
        /// <param name="proposedType">Optional. Expected file's type.</param>
        /// <returns>mime type, e.g.: "application/octet-stream"</returns>
        public static string FindMimeByContent(string file
            ,string proposedType)
        {
            FileInfo fi = new FileInfo(file);
            if (!fi.Exists)
                throw new FileNotFoundException(file);
            byte[] buf = new byte[Math.Min(4096L,fi.Length)];
            using (FileStream fs = File.OpenRead(file))
                fs.Read(buf,0,buf.Length);
            return FindMimeByData(buf,proposedType);
        }

        /// <summary>Finds mime type for binary data.</summary>
        /// <param name="dataBytes">Binary data to examine.</param>
        /// <param name="mimeProposed">Optional. Expected mime type.</param>
        /// <returns>mime type, e.g.: "application/octet-stream"</returns>
        public static string FindMimeByData(byte[] dataBytes,string mimeProposed)
        {
            if (dataBytes == null || dataBytes.Length == 0)
                throw new ArgumentNullException("dataBytes");
            string mimeRet = String.Empty;
            IntPtr outPtr = IntPtr.Zero;
            if (!String.IsNullOrEmpty(mimeProposed))
                mimeRet = mimeProposed;
            int result = FindMimeFromData(IntPtr.Zero
                ,null
                ,dataBytes
                ,dataBytes.Length
                ,String.IsNullOrEmpty(mimeProposed) ? null : mimeProposed
                ,0
                ,out outPtr
                ,0);
            if (result != 0)
                throw Marshal.GetExceptionForHR(result);
            if (outPtr != null && outPtr != IntPtr.Zero)
            {
                mimeRet = Marshal.PtrToStringUni(outPtr);
                Marshal.FreeCoTaskMem(outPtr);
            }
            return mimeRet;
        }

        [DllImport("urlmon.dll"
            ,CharSet = CharSet.Unicode
            ,ExactSpelling = true
            ,SetLastError = true)]
        static extern Int32 FindMimeFromData(IntPtr pBC
            ,[MarshalAs(UnmanagedType.LPWStr)] String pwzUrl
            ,[MarshalAs(UnmanagedType.LPArray,ArraySubType = UnmanagedType.I1,SizeParamIndex = 3)] Byte[] pBuffer
            ,Int32 cbSize
            ,[MarshalAs(UnmanagedType.LPWStr)] String pwzMimeProposed
            ,Int32 dwMimeFlags
            ,out IntPtr ppwzMimeOut
            ,Int32 dwReserved);

        private static MimeTypeCollection _extensionTypes = null;
        private static MimeTypeCollection ExtensionTypes
        {
            get
            {
                if (_extensionTypes == null)
                    _extensionTypes = new MimeTypeCollection();
                return _extensionTypes;
            }
        }

        [Serializable]
        [XmlRoot(ElementName = "mimeTypes")]
        private class MimeTypeCollection : List<MimeTypeCollection.mimeTypeInfo>
        {
            private SortedList<string,string> _extensions;
            private SortedList<string,List<string>> _mimes;

            private void Init()
            {
                if (_extensions == null || _mimes == null
                    || _extensions.Count == 0 || _mimes.Count == 0)
                {
                    _extensions = new SortedList<string,string>(StringComparer.OrdinalIgnoreCase);
                    _mimes = new SortedList<string,List<string>>(StringComparer.OrdinalIgnoreCase);
                    foreach (var mime in this)
                    {
                        _mimes.Add(mime.MimeType,new List<string>(mime.Extensions));
                        foreach (string ext in mime.Extensions)
                            if (!_extensions.ContainsKey(ext))
                                _extensions.Add(ext,mime.MimeType);
                    }
                }
            }

            public String GetExtension(string type)
            {
                Init();
                return _mimes.ContainsKey(type) ? _mimes[type][0] : string.Empty;
            }

            public String GetMimeType(string extension)
            {
                Init();
                return _extensions.ContainsKey(extension) ? _extensions[extension] : string.Empty;
            }

        public MimeTypeCollection()
        {
            this.Add(new mimeTypeInfo("application/applixware",new List<string>(new[] { ".aw" })));
            this.Add(new mimeTypeInfo("application/atom+xml",new List<string>(new[] { ".atom" })));
            // ... Whole list from apache's site
            this.Add(new mimeTypeInfo("x-x509-ca-cert",new List<string>(new[] { ".cer" })));
            try
            {
                using (RegistryKey classesRoot = Registry.ClassesRoot)
                using (RegistryKey typeKey = classesRoot.OpenSubKey(@"MIME\Database\Content Type"))
                {
                    string[] subKeyNames = typeKey.GetSubKeyNames();
                    string extension = string.Empty;
                    foreach (string keyname in subKeyNames)
                    {
                        string trimmed = (keyname ?? string.Empty).Trim();
                        if (string.IsNullOrEmpty(trimmed))
                            continue;
                        if (!String.IsNullOrEmpty(GetExtension(trimmed)))
                            continue;
                        string subKey = "MIME\\Database\\Content Type\\" + trimmed;
                        using (RegistryKey curKey = classesRoot.OpenSubKey(subKey))
                        {
                            extension = (curKey.GetValue("Extension") as string ?? string.Empty).Trim();
                            if (extension.Length > 0)
                                this.Add(new mimeTypeInfo(trimmed
                                    ,new List<string>(new[] { extension })));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                string s = ex.ToString();
            }
        }

        [Serializable]
        public class mimeTypeInfo
        {
            [XmlAttribute(AttributeName = "mimeType")]
            public String MimeType { get; set; }

            [XmlElement("extension")]
            public List<String> Extensions { get; set; }

            public mimeTypeInfo(string mimeType,List<string> extensions)
            {
                MimeType = mimeType;
                Extensions = extensions;
            }

            public mimeTypeInfo() { }
        }
    }
}

}

}

#3

The System.Web.MimeMapping has 3 versions - two version 4.0s (where one of these is internal), and then a version 2.0 which is also internal. As pointed out, there is a public version of the class in System.Web version 4.0 for the .NET 4.5 framework.

包含。MimeMapping有3个版本——两个版本4。0(其中一个是内部的)，然后一个版本2.0也是内部的。如前所述，系统中有一个类的公共版本。net 4.5框架的Web版本4.0。

For RoadkillWiki I've basically reverse engineered it to save the bother of reflecting each time, the Wiki's file handler tries to the use IIS/applicationhost.config by default, and then falls through to the MimeMapping class:

对于RoadkillWiki，我基本上是反向设计了它，以节省每次反射的麻烦，Wiki的文件处理程序尝试使用IIS/applicationhost。默认设置，然后进入MimeMapping类:

private string GetMimeType(string fileExtension, ServerManager serverManager)
{
    try
    {
        string mimeType = "text/plain";

        Microsoft.Web.Administration.Configuration config = serverManager.GetApplicationHostConfiguration();
        ConfigurationSection staticContentSection = config.GetSection("system.webServer/staticContent");
        ConfigurationElementCollection mimemaps = staticContentSection.GetCollection();

        ConfigurationElement element = mimemaps.FirstOrDefault(m => m.Attributes["fileExtension"].Value.ToString() == fileExtension);

        if (element != null)
            mimeType = element.Attributes["mimeType"].Value.ToString();

        return mimeType;
    }
    catch (UnauthorizedAccessException)
    {
        // Shared hosting won't have access to the applicationhost.config file
        return MimeMapping.GetMimeMapping("." +fileExtension);
    }
}

And MimeMapping:

和MimeMapping:

public class MimeMapping
{
    private static Dictionary<string, string> ExtensionMap = new Dictionary<string, string>();

    static MimeMapping()
    {
        ExtensionMap.Add(".323", "text/h323");
        ExtensionMap.Add(".asx", "video/x-ms-asf");
        ExtensionMap.Add(".acx", "application/internet-property-stream");
        ExtensionMap.Add(".ai", "application/postscript");
        ExtensionMap.Add(".aif", "audio/x-aiff");
        ExtensionMap.Add(".aiff", "audio/aiff");
        ExtensionMap.Add(".axs", "application/olescript");
        ExtensionMap.Add(".aifc", "audio/aiff");
        ExtensionMap.Add(".asr", "video/x-ms-asf");
        ExtensionMap.Add(".avi", "video/x-msvideo");
        ExtensionMap.Add(".asf", "video/x-ms-asf");
        ExtensionMap.Add(".au", "audio/basic");
        ExtensionMap.Add(".application", "application/x-ms-application");
        ExtensionMap.Add(".bin", "application/octet-stream");
        ExtensionMap.Add(".bas", "text/plain");
        ExtensionMap.Add(".bcpio", "application/x-bcpio");
        ExtensionMap.Add(".bmp", "image/bmp");
        ExtensionMap.Add(".cdf", "application/x-cdf");
        ExtensionMap.Add(".cat", "application/vndms-pkiseccat");
        ExtensionMap.Add(".crt", "application/x-x509-ca-cert");
        ExtensionMap.Add(".c", "text/plain");
        ExtensionMap.Add(".css", "text/css");
        ExtensionMap.Add(".cer", "application/x-x509-ca-cert");
        ExtensionMap.Add(".crl", "application/pkix-crl");
        ExtensionMap.Add(".cmx", "image/x-cmx");
        ExtensionMap.Add(".csh", "application/x-csh");
        ExtensionMap.Add(".cod", "image/cis-cod");
        ExtensionMap.Add(".cpio", "application/x-cpio");
        ExtensionMap.Add(".clp", "application/x-msclip");
        ExtensionMap.Add(".crd", "application/x-mscardfile");
        ExtensionMap.Add(".deploy", "application/octet-stream");
        ExtensionMap.Add(".dll", "application/x-msdownload");
        ExtensionMap.Add(".dot", "application/msword");
        ExtensionMap.Add(".doc", "application/msword");
        ExtensionMap.Add(".dvi", "application/x-dvi");
        ExtensionMap.Add(".dir", "application/x-director");
        ExtensionMap.Add(".dxr", "application/x-director");
        ExtensionMap.Add(".der", "application/x-x509-ca-cert");
        ExtensionMap.Add(".dib", "image/bmp");
        ExtensionMap.Add(".dcr", "application/x-director");
        ExtensionMap.Add(".disco", "text/xml");
        ExtensionMap.Add(".exe", "application/octet-stream");
        ExtensionMap.Add(".etx", "text/x-setext");
        ExtensionMap.Add(".evy", "application/envoy");
        ExtensionMap.Add(".eml", "message/rfc822");
        ExtensionMap.Add(".eps", "application/postscript");
        ExtensionMap.Add(".flr", "x-world/x-vrml");
        ExtensionMap.Add(".fif", "application/fractals");
        ExtensionMap.Add(".gtar", "application/x-gtar");
        ExtensionMap.Add(".gif", "image/gif");
        ExtensionMap.Add(".gz", "application/x-gzip");
        ExtensionMap.Add(".hta", "application/hta");
        ExtensionMap.Add(".htc", "text/x-component");
        ExtensionMap.Add(".htt", "text/webviewhtml");
        ExtensionMap.Add(".h", "text/plain");
        ExtensionMap.Add(".hdf", "application/x-hdf");
        ExtensionMap.Add(".hlp", "application/winhlp");
        ExtensionMap.Add(".html", "text/html");
        ExtensionMap.Add(".htm", "text/html");
        ExtensionMap.Add(".hqx", "application/mac-binhex40");
        ExtensionMap.Add(".isp", "application/x-internet-signup");
        ExtensionMap.Add(".iii", "application/x-iphone");
        ExtensionMap.Add(".ief", "image/ief");
        ExtensionMap.Add(".ivf", "video/x-ivf");
        ExtensionMap.Add(".ins", "application/x-internet-signup");
        ExtensionMap.Add(".ico", "image/x-icon");
        ExtensionMap.Add(".jpg", "image/jpeg");
        ExtensionMap.Add(".jfif", "image/pjpeg");
        ExtensionMap.Add(".jpe", "image/jpeg");
        ExtensionMap.Add(".jpeg", "image/jpeg");
        ExtensionMap.Add(".js", "application/x-javascript");
        ExtensionMap.Add(".lsx", "video/x-la-asf");
        ExtensionMap.Add(".latex", "application/x-latex");
        ExtensionMap.Add(".lsf", "video/x-la-asf");
        ExtensionMap.Add(".manifest", "application/x-ms-manifest");
        ExtensionMap.Add(".mhtml", "message/rfc822");
        ExtensionMap.Add(".mny", "application/x-msmoney");
        ExtensionMap.Add(".mht", "message/rfc822");
        ExtensionMap.Add(".mid", "audio/mid");
        ExtensionMap.Add(".mpv2", "video/mpeg");
        ExtensionMap.Add(".man", "application/x-troff-man");
        ExtensionMap.Add(".mvb", "application/x-msmediaview");
        ExtensionMap.Add(".mpeg", "video/mpeg");
        ExtensionMap.Add(".m3u", "audio/x-mpegurl");
        ExtensionMap.Add(".mdb", "application/x-msaccess");
        ExtensionMap.Add(".mpp", "application/vnd.ms-project");
        ExtensionMap.Add(".m1v", "video/mpeg");
        ExtensionMap.Add(".mpa", "video/mpeg");
        ExtensionMap.Add(".me", "application/x-troff-me");
        ExtensionMap.Add(".m13", "application/x-msmediaview");
        ExtensionMap.Add(".movie", "video/x-sgi-movie");
        ExtensionMap.Add(".m14", "application/x-msmediaview");
        ExtensionMap.Add(".mpe", "video/mpeg");
        ExtensionMap.Add(".mp2", "video/mpeg");
        ExtensionMap.Add(".mov", "video/quicktime");
        ExtensionMap.Add(".mp3", "audio/mpeg");
        ExtensionMap.Add(".mpg", "video/mpeg");
        ExtensionMap.Add(".ms", "application/x-troff-ms");
        ExtensionMap.Add(".nc", "application/x-netcdf");
        ExtensionMap.Add(".nws", "message/rfc822");
        ExtensionMap.Add(".oda", "application/oda");
        ExtensionMap.Add(".ods", "application/oleobject");
        ExtensionMap.Add(".pmc", "application/x-perfmon");
        ExtensionMap.Add(".p7r", "application/x-pkcs7-certreqresp");
        ExtensionMap.Add(".p7b", "application/x-pkcs7-certificates");
        ExtensionMap.Add(".p7s", "application/pkcs7-signature");
        ExtensionMap.Add(".pmw", "application/x-perfmon");
        ExtensionMap.Add(".ps", "application/postscript");
        ExtensionMap.Add(".p7c", "application/pkcs7-mime");
        ExtensionMap.Add(".pbm", "image/x-portable-bitmap");
        ExtensionMap.Add(".ppm", "image/x-portable-pixmap");
        ExtensionMap.Add(".pub", "application/x-mspublisher");
        ExtensionMap.Add(".pnm", "image/x-portable-anymap");
        ExtensionMap.Add(".pml", "application/x-perfmon");
        ExtensionMap.Add(".p10", "application/pkcs10");
        ExtensionMap.Add(".pfx", "application/x-pkcs12");
        ExtensionMap.Add(".p12", "application/x-pkcs12");
        ExtensionMap.Add(".pdf", "application/pdf");
        ExtensionMap.Add(".pps", "application/vnd.ms-powerpoint");
        ExtensionMap.Add(".p7m", "application/pkcs7-mime");
        ExtensionMap.Add(".pko", "application/vndms-pkipko");
        ExtensionMap.Add(".ppt", "application/vnd.ms-powerpoint");
        ExtensionMap.Add(".pmr", "application/x-perfmon");
        ExtensionMap.Add(".pma", "application/x-perfmon");
        ExtensionMap.Add(".pot", "application/vnd.ms-powerpoint");
        ExtensionMap.Add(".prf", "application/pics-rules");
        ExtensionMap.Add(".pgm", "image/x-portable-graymap");
        ExtensionMap.Add(".qt", "video/quicktime");
        ExtensionMap.Add(".ra", "audio/x-pn-realaudio");
        ExtensionMap.Add(".rgb", "image/x-rgb");
        ExtensionMap.Add(".ram", "audio/x-pn-realaudio");
        ExtensionMap.Add(".rmi", "audio/mid");
        ExtensionMap.Add(".ras", "image/x-cmu-raster");
        ExtensionMap.Add(".roff", "application/x-troff");
        ExtensionMap.Add(".rtf", "application/rtf");
        ExtensionMap.Add(".rtx", "text/richtext");
        ExtensionMap.Add(".sv4crc", "application/x-sv4crc");
        ExtensionMap.Add(".spc", "application/x-pkcs7-certificates");
        ExtensionMap.Add(".setreg", "application/set-registration-initiation");
        ExtensionMap.Add(".snd", "audio/basic");
        ExtensionMap.Add(".stl", "application/vndms-pkistl");
        ExtensionMap.Add(".setpay", "application/set-payment-initiation");
        ExtensionMap.Add(".stm", "text/html");
        ExtensionMap.Add(".shar", "application/x-shar");
        ExtensionMap.Add(".sh", "application/x-sh");
        ExtensionMap.Add(".sit", "application/x-stuffit");
        ExtensionMap.Add(".spl", "application/futuresplash");
        ExtensionMap.Add(".sct", "text/scriptlet");
        ExtensionMap.Add(".scd", "application/x-msschedule");
        ExtensionMap.Add(".sst", "application/vndms-pkicertstore");
        ExtensionMap.Add(".src", "application/x-wais-source");
        ExtensionMap.Add(".sv4cpio", "application/x-sv4cpio");
        ExtensionMap.Add(".tex", "application/x-tex");
        ExtensionMap.Add(".tgz", "application/x-compressed");
        ExtensionMap.Add(".t", "application/x-troff");
        ExtensionMap.Add(".tar", "application/x-tar");
        ExtensionMap.Add(".tr", "application/x-troff");
        ExtensionMap.Add(".tif", "image/tiff");
        ExtensionMap.Add(".txt", "text/plain");
        ExtensionMap.Add(".texinfo", "application/x-texinfo");
        ExtensionMap.Add(".trm", "application/x-msterminal");
        ExtensionMap.Add(".tiff", "image/tiff");
        ExtensionMap.Add(".tcl", "application/x-tcl");
        ExtensionMap.Add(".texi", "application/x-texinfo");
        ExtensionMap.Add(".tsv", "text/tab-separated-values");
        ExtensionMap.Add(".ustar", "application/x-ustar");
        ExtensionMap.Add(".uls", "text/iuls");
        ExtensionMap.Add(".vcf", "text/x-vcard");
        ExtensionMap.Add(".wps", "application/vnd.ms-works");
        ExtensionMap.Add(".wav", "audio/wav");
        ExtensionMap.Add(".wrz", "x-world/x-vrml");
        ExtensionMap.Add(".wri", "application/x-mswrite");
        ExtensionMap.Add(".wks", "application/vnd.ms-works");
        ExtensionMap.Add(".wmf", "application/x-msmetafile");
        ExtensionMap.Add(".wcm", "application/vnd.ms-works");
        ExtensionMap.Add(".wrl", "x-world/x-vrml");
        ExtensionMap.Add(".wdb", "application/vnd.ms-works");
        ExtensionMap.Add(".wsdl", "text/xml");
        ExtensionMap.Add(".xml", "text/xml");
        ExtensionMap.Add(".xlm", "application/vnd.ms-excel");
        ExtensionMap.Add(".xaf", "x-world/x-vrml");
        ExtensionMap.Add(".xla", "application/vnd.ms-excel");
        ExtensionMap.Add(".xls", "application/vnd.ms-excel");
        ExtensionMap.Add(".xof", "x-world/x-vrml");
        ExtensionMap.Add(".xlt", "application/vnd.ms-excel");
        ExtensionMap.Add(".xlc", "application/vnd.ms-excel");
        ExtensionMap.Add(".xsl", "text/xml");
        ExtensionMap.Add(".xbm", "image/x-xbitmap");
        ExtensionMap.Add(".xlw", "application/vnd.ms-excel");
        ExtensionMap.Add(".xpm", "image/x-xpixmap");
        ExtensionMap.Add(".xwd", "image/x-xwindowdump");
        ExtensionMap.Add(".xsd", "text/xml");
        ExtensionMap.Add(".z", "application/x-compress");
        ExtensionMap.Add(".zip", "application/x-zip-compressed");
        ExtensionMap.Add(".*", "application/octet-stream");
    }

    public static string GetMimeMapping(string fileExtension)
    {
        if (ExtensionMap.ContainsKey(fileExtension))
            return ExtensionMap[fileExtension];
        else
            return ExtensionMap[".*"];
    }
}

#4

I've written a program to fetch and convert the Apache mime.types file to a C# Dictionary<string, string> keyed by file extension. It's here:

我编写了一个程序来获取和转换Apache mime。将文件类型设置为c# Dictionary 按文件扩展名键控。在这里: ,>

https://github.com/cymen/ApacheMimeTypesToDotNet

https://github.com/cymen/ApacheMimeTypesToDotNet

The actual output is this file:

实际输出是这个文件:

https://github.com/cymen/ApacheMimeTypesToDotNet/blob/master/ApacheMimeTypes.cs

https://github.com/cymen/ApacheMimeTypesToDotNet/blob/master/ApacheMimeTypes.cs

Hopefully someone else finds it useful too!

希望其他人也能发现它的用处!

#5

Nisus - would you be willing to post the entire source code for your utility somewhere? that would really be helpful. thanks!

Nisus -你是否愿意将你的工具的全部源代码发布到某个地方?那真的很有帮助。谢谢!

Never mind....

更不用说....

I edited the apache definition file to only contain entries with defined extensions, then extended the code to load in the types/extensions from the text file at run time. Not elegant perhaps but sure beats creating/maintaining 630 lines of source code for the mime types.

我编辑了apache定义文件，只包含有定义扩展的条目，然后在运行时将代码扩展到文本文件的类型/扩展中。也许不太优雅，但肯定比为mime类型创建/维护630行源代码要好。

[in the constructor for MimeTypeCollection instead of this stuff: this.Add(new mimeTypeInfo("application/applixware",new List(new[] { ".aw" })));]

在MimeTypeCollection的构造函数中，而不是这个:this。添加(新的mimeTypeInfo(“application/applixware”，新列表(new[]{)。aw“})));

        // import mime/extension definition list to facilitate maintenance
    string dir = AppDomain.CurrentDomain.BaseDirectory;
    using (TextReader streamReader = new StreamReader(Path.Combine(dir, "MimeDefinitions.txt")))
    {
      string input;
      while ((input = streamReader.ReadLine()) != null)
      {
        if (input.Substring(0, 1) != "#")
        {
          // text line format ::= [contenttype]<tab>[space delimited list of extensions, without dot]
          string contentType = input.Group("0\t1");
          string extensionList = input.Group("1\t1");
          string[] extensions = extensionList.Split(" ".ToCharArray());
          List<string> extensionSet = new List<string>();
          foreach (string term in extensions)
          {
            extensionSet.Add("."+term);
          }
          this.Add(new mimeTypeInfo(contentType, extensionSet));
        }
      }
    }

I also found that the Init() method would be called and the _extensions and _mime members would not be completely initialized so I changed it to read:

我还发现Init()方法将被调用，_extensions和_mime成员将不会被完全初始化，因此我将其更改为读取:

if (_extensions == null || _mimes == null || _mimes.Count != this.Count)

Anyway, I now how a class that can handle the external defs and local registry I needed.

不管怎样，我现在讲的是如何处理外部缺陷和本地注册表的类。

Thanks!

谢谢!

#6

I also found that the Init() method would be called and the _extensions and _mime members would not be completely initialized so I changed it to read, and the best way is, remove call GetExtension in constructor from MimeTypeCollection:

我还发现Init()方法将被调用，_extensions和_mime成员将不会被完全初始化，所以我将其更改为read，最好的方法是，从MimeTypeCollection中删除构造函数中的调用GetExtension:

        public MimeTypeCollection()
        {
            this.Add(new mimeTypeInfo("application/applixware", new List<string>(new[] { ".aw" })));
            this.Add(new mimeTypeInfo("application/atom+xml", new List<string>(new[] { ".atom" })));
            // ... Whole list from apache's site
            this.Add(new mimeTypeInfo("x-x509-ca-cert", new List<string>(new[] { ".cer" })));
            try
            {
                using (RegistryKey classesRoot = Registry.ClassesRoot)
                using (RegistryKey typeKey = classesRoot.OpenSubKey(@"MIME\Database\Content Type"))
                {
                    string[] subKeyNames = typeKey.GetSubKeyNames();
                    string extension = string.Empty;
                    foreach (string keyname in subKeyNames)
                    {
                        string trimmed = (keyname ?? string.Empty).Trim();
                        if (string.IsNullOrEmpty(trimmed))
                            continue;
                        if (this.Exists(mime => mime.MimeType == trimmed))
                            continue;
                        //if (!String.IsNullOrEmpty(GetExtension(trimmed)))
                        //  continue;
                        string subKey = "MIME\\Database\\Content Type\\" + trimmed;
                        using (RegistryKey curKey = classesRoot.OpenSubKey(subKey))
                        {
                            extension = (curKey.GetValue("Extension") as string ?? string.Empty).Trim();
                            if (extension.Length > 0)
                                this.Add(new mimeTypeInfo(trimmed
                                        , new List<string>(new[] { extension })));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                string s = ex.ToString();
            }
        }