Les extensions de fichiers et Types MIME .NET

Question

Je veux obtenir un Contenu MIME-Type à partir d'un compte tenu de l'extension (de préférence sans avoir à accéder au fichier physique). J'ai vu certaines questions à ce sujet et les méthodes décrites pour effectuer ce peut être repris dans:

1. Utilisation des informations du registre.
2. Utilisation urlmon.dll's FindMimeFromData.
3. Utiliser les informations de IIS.
4. Rouler votre propre mappage MIME fonction. Basé sur cette table, par exemple.

J'ai été en utilisant pas.1 pour un certain temps, mais j'ai réalisé que les informations fournies par le registre n'est pas uniforme et dépend du logiciel installé sur la machine. Certaines extensions, comme .zip ne pas utiliser pour un Type de Contenu spécifié.

Solution pas.2 me force à avoir le fichier sur le disque, afin de lire les premiers octets, ce qui est quelque chose de lent, mais peut obtenir de bons résultats.

La troisième méthode est basée sur les Services d'Annuaire et tout ça, qui est quelque chose que je n'aime pas beaucoup, parce que je dois ajouter des références COM et je ne suis pas sûr que c'est cohérente entre les IIS6 et IIS7. Aussi, je ne connais pas les performances de cette méthode.

Enfin, je ne veux pas utiliser ma propre table, mais à la fin me semble la meilleure option si je veux un rendement décent et de la cohérence des résultats entre les plates-formes (même en Mono).

Pensez-vous qu'il est une meilleure option que d'utiliser ma propre table ou l'une des autres méthodes décrites ci-dessus sont les meilleures? Quelle est votre expérience?

Answer 1

Cela dépend de ce que vous avez besoin de le type MIME. En général, pour les services (applications web, web service, etc.), il est conseillé de ne pas utiliser un MIME liste qui dépend des paramètres du système d'exploitation, ou de secours si vous ne trouvez pas les informations MIME autrement.

Je pense que c'est aussi la raison pourquoi MS a choisi de mettre constante des types MIME dans leur Système.Web.MimeMapping classe (c'est malheureusement interne, pour quelque raison que ce soit).

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+

Pas de wrapper exige, d'appel public à la méthode de System.Web.MimeMapping.GetMimeMapping directement.

Answer 2

J'ai combiné tous ces approches dans mon utilitaire lib, à l'exception peut-être pas.3. Btw, pas.2 (urlmon.dll) ne nécessite pas de fichier statique, elle prend simplement quelques octets peu importe d'où ils étaient venus. Voici ma classe actuelle

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() { }
		}
	}
}

}

Answer 3

L' System.Web.MimeMapping a 3 versions - deux version 4.0 s (où l'un de ces est interne), puis une version 2.0 qui est aussi interne. Comme l'a souligné, il y a une version publique de la classe dans le Système.Web version 4.0 pour l' .NET 4.5 framework.

Pour RoadkillWiki j'ai fait une rétro-ingénierie pour enregistrer la peine de réfléchir à chaque fois, le Wiki du gestionnaire de fichier tente de l'utiliser IIS/applicationhost.config par défaut, puis passe à travers le MimeMapping classe:

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

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

Answer 4

J'ai écrit un programme pour extraire et convertir les Apache mime.les types de fichier C# Dictionary<string, string> gérés par l'extension de fichier. C'est par ici:

https://github.com/cymen/ApacheMimeTypesToDotNet

La production réelle est ce fichier:

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

J'espère que quelqu'un d'autre le trouve utile aussi!

Answer 5

Nisus - seriez-vous prêt à publier la totalité du code source de votre utilitaire de quelque part? qui serait vraiment utile. merci!

Jamais l'esprit....

J'ai édité le apache fichier de définition pour ne contenir que les entrées avec des extensions définies, puis prolongé le code à charger dans les types/extensions à partir du fichier texte au moment de l'exécution. Pas très élégant, peut-être, mais que par battements de créer ou de maintenir 630 lignes de code source pour les types mime.

[dans le constructeur de MimeTypeCollection à la place de ce genre de choses: c'.Add(new mimeTypeInfo("application/applixware",new Liste(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));
        }
      }
    }

J'ai aussi trouvé que la méthode Init() sera appelée et de l'_extensions et _mime membres ne seraient pas complètement initialisé, donc je l'ai changé pour lire:

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

De toute façon, j'ai maintenant comment une classe peut gérer l'externe defs et du registre local dont j'avais besoin.

Merci!