mimetypemap - Extensiones de archivos y tipos MIME en.NET

getmimetype php

Question

Quiero obtener un tipo de contenido MIME desde una extensión dada (preferiblemente sin acceder al archivo físico). He visto algunas preguntas sobre esto y los métodos descritos para realizar esto pueden resumirse en:

1. Use información de registro .
2. Use FindMimeFromData de urlmon.dll .
3. Use la información de IIS .
4. Tira tu propia función de mapeo MIME. Basado en esta tabla , por ejemplo.

He estado usando no.1 durante un tiempo, pero me di cuenta de que la información proporcionada por el registro no es coherente y depende del software instalado en la máquina. Algunas extensiones, como .zip, no suelen tener especificado un tipo de contenido.

La solución n. ° 2 me obliga a tener el archivo en el disco para leer los primeros bytes, lo cual es algo lento pero puede obtener buenos resultados.

El tercer método se basa en los Servicios de directorio y todo eso, que es algo que no me gusta mucho porque tengo que agregar referencias COM y no estoy seguro de que sea coherente entre IIS6 e IIS7. Además, no sé el rendimiento de este método.

Finalmente, no quería usar mi propia tabla, pero al final parece ser la mejor opción si quiero un rendimiento decente y la coherencia de los resultados entre plataformas (incluso Mono).

¿Crees que hay una mejor opción que usar mi propia tabla o uno de los otros métodos descritos es mejor? ¿Cuál es tu experiencia?

Answer 1

No tengo una amplia gama de tipos de mime para manejar en mis aplicaciones, así que estoy usando una tabla de búsqueda como tú.

Porque tu idea no era tan mala en absoluto. Solo necesita tener una manera fácil de mantener y actualizar la búsqueda.

Answer 2

He combinado todos estos enfoques en mi lib de utilidad, excepto tal vez no.3. Por cierto, no.2 (urlmon.dll) no requiere archivo estático, simplemente toma algunos bytes sin importar de dónde vienen. Esta es mi clase actual

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

Nisus: ¿estarías dispuesto a publicar todo el código fuente de tu utilidad en alguna parte? eso sería realmente útil. ¡Gracias!

No importa....

Edité el archivo de definición de apache para que solo contenga entradas con extensiones definidas, luego extendí el código para cargar los tipos / extensiones desde el archivo de texto en tiempo de ejecución. Aunque no es elegante, es seguro que crea / mantiene 630 líneas de código fuente para los tipos de mimo.

[en el constructor de MimeTypeCollection en lugar de esto: this.Add (new mimeTypeInfo ("application / applixware", new List (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));
}
}
}

También encontré que se llamaría al método Init () y los miembros _extensions y _mime no se inicializarían completamente, así que lo cambié para leer:

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

De todos modos, ahora cómo una clase que puede manejar las defs externas y el registro local que necesitaba.

¡Gracias!

Answer 4

También encontré que se llamaría al método Init () y los miembros _extensions y _mime no se inicializarían completamente, así que lo cambié para leer, y la mejor manera es eliminar la llamada GetExtension en el constructor de 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();
}
}

Answer 5

Escribí un programa para buscar y convertir el archivo mime.types de Apache en un C # Dictionary<string, string> codificado por la extensión de archivo. Esta aquí:

https://github.com/cymen/ApacheMimeTypesToDotNet

El resultado real es este archivo:

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

¡Ojalá alguien más también lo encuentre útil!

Answer 6

System.Web.MimeMapping tiene 3 versiones: dos versiones 4.0 (donde una de ellas es interna) y luego una versión 2.0 que también es interna. Como se señaló, hay una versión pública de la clase en System.Web versión 4.0 para .NET 4.5 framework.

Para RoadkillWiki, básicamente lo he diseñado por ingeniería inversa para evitar la molestia de reflejar cada vez, el manejador de archivos de Wiki intenta utilizar IIS / applicationhost.config de manera predeterminada, y luego pasa a la clase 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);
}
}

Y 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 7

Depende de lo que necesite el tipo MIME. En general, para servicios (aplicaciones web, servicios web, etc.), es aconsejable no utilizar una lista MIME que dependa de la configuración del sistema operativo, o solo como alternativa si no puede encontrar información MIME de lo contrario.

Creo que esta es también la razón por la cual MS eligió poner tipos MIME constantes en su clase System.Web.MimeMapping (desafortunadamente es interno, por la razón que sea).

Editar:

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+

No se requiere envoltorio, llame directamente al método público System.Web.MimeMapping.GetMimeMapping .