Расширения файлов и типы MIME in.NET

Я хочу получить тип содержимого MIME из данного расширения (желательно без доступа к физическому файлу). Я видел некоторые вопросы об этом и методы, описанные для выполнения этого можно возобновить в:

  1. использовать информацию реестра.
  2. использовать urlmon.dll-это FindMimeFromData.
  3. использовать информацию IIS.
  4. сверните свою собственную функцию отображения MIME. На основе в этой таблице, например.

Я используя no.1 в течение некоторого времени, но я понял, что информация, предоставленная реестром, не является согласованной и зависит от программного обеспечения, установленного на машине. Некоторые расширения, например .zip не используется для указания типа контента.

решение № 2 заставляет меня иметь файл на диске, чтобы прочитать первые байты, что является чем-то медленным, но может получить хорошие результаты.

третий метод основан на службах каталогов и все такое, что мне не нравится многое, потому что я должен добавить ссылки COM, и я не уверен, что это согласуется между IIS6 и IIS7. Кроме того, я не знаю эффективность этого метода.

наконец, я не хотел использовать свою собственную таблицу, но в конце кажется лучшим вариантом, если я хочу достойную производительность и согласованность результатов между платформами (даже моно).

Как вы думаете, есть лучший вариант, чем использовать мою собственную таблицу или один из других описанных методов лучше? Каков ваш опыт?

6 53
.net asp.net-mvc content-type mime file-extension

6 ответов:

это зависит от того, что вам нужно тип MIME для. В общем, для сервисов (веб-приложения, веб-сервис и т. д.), рекомендуется не использовать список MIME, который зависит от настроек ОС, или только в качестве запасного варианта, если вы не можете найти информацию MIME в противном случае.

Я думаю, что это также причина, по которой MS решила поместить постоянные типы MIME в их System.Web.MimeMapping класс (к сожалению, это внутренний, по какой-то причине).

Edit:

обертка ( 
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 });
    }
}

обертка (.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+

не требуется обертка, вызовите открытый метод System.Web.MimeMapping.GetMimeMapping напрямую.

71

Я объединил все эти подходы в моей утилите lib, за исключением, может быть, № 3. Кстати, № 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() { }
        }
    }
}

}

14

The System.Web.MimeMapping имеет 3 версии-две версии 4.0 s (где одна из них является внутренней), а затем версия 2.0, которая также является внутренней. Как уже отмечалось, существует общедоступная версия класса в системе.Веб-версия 4.0 для платформы .NET 4.5.

для RoadkillWiki я в основном перепроектировал его, чтобы сохранить беспокойство о отражении каждый раз, обработчик файлов Вики пытается использовать 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);
    }
}

И 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[".*"];
    }
}
8

Я написал программу для извлечения и преобразования Apache mime.типы файлов на C# Dictionary<string, string> ключ по расширению файла. Это здесь:

https://github.com/cymen/ApacheMimeTypesToDotNet

фактический вывод-это файл:

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

надеюсь, кто-то еще находит это полезным!

7

Nisus - вы хотели бы разместить весь исходный код для вашей утилиты где-нибудь? это было бы действительно полезно. спасибо!

Не обращай внимания....

я отредактировал файл определения apache, чтобы он содержал только записи с определенными расширениями, а затем расширил код для загрузки в типы/расширения из текстового файла во время выполнения. Не элегантный, возможно, но уверен, что бьет создание/поддержание 630 строк исходного кода для типов mime.

[в конструктор для MimeTypeCollection вместо этого материала: этот.Добавить(новый mimeTypeInfo("приложения/applixware",новый список(новый[] { ".ОУ" })));]

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

Я также обнаружил, что метод Init () будет вызван, а члены _extensions и _mime не будут полностью инициализированы, поэтому я изменил его на чтение:

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

в любом случае, я теперь как класс, который может обрабатывать внешние defs и локальный реестр мне нужно.

спасибо!

1

Я также обнаружил, что метод Init() будет вызван, а члены _extensions и _mime не будут полностью инициализированы, поэтому я изменил его на чтение, и лучший способ-удалить вызов GetExtension в конструкторе из MimeTypeCollection:

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