.NET का उपयोग करके, आप फ़ाइल हस्ताक्षर के आधार पर फ़ाइल के माइम प्रकार को कैसे पा सकते हैं, इसका विस्तार नहीं है


241

मैं माइम प्रकार प्राप्त करने के लिए एक सरल तरीके की तलाश कर रहा हूं, जहां फ़ाइल एक्सटेंशन गलत है या नहीं दिया गया है, इस प्रश्न के समान कुछ ही .Net में है।


यह इस सवाल के समान लगता है ।
ग्रेग हेवगिल सेप

22
काश मैं आवश्यकता के स्पष्ट रूप से फाइल एक्सटेंशन का उपयोग करते हुए अभी भी सभी "नकली उत्तर" को हटा सकता हूं, एक्सटेंशन का उपयोग न करें!
एडवर्ड ओलिमिसन

1
यह एक पुराना प्रश्न हो सकता है, लेकिन समस्या अभी भी बनी हुई है। मैं यहाँ हर उत्तर को इस आधार पर रद्द कर दूंगा कि वे केवल अपनी सामग्री द्वारा विंडोज निष्पादन योग्य वस्तुओं की जांच करते हैं; लिनक्स या iOS निष्पादन योग्य या खतरनाक फ़ाइलों के बारे में क्या?
फिलिप

@PhillipH उन लोगों के लिए एक उत्तर लिखें।
wazz

जवाबों:


83

Urlmon.dll में, एक फ़ंक्शन है जिसे कहा जाता है FindMimeFromData

प्रलेखन से

MIME प्रकार का पता लगाना, या "डेटा सूँघना", बाइनरी डेटा से एक उपयुक्त MIME प्रकार का निर्धारण करने की प्रक्रिया को संदर्भित करता है। अंतिम परिणाम सर्वर द्वारा आपूर्ति की गई MIME प्रकार हेडर, फ़ाइल एक्सटेंशन और / या डेटा के संयोजन पर निर्भर करता है। आमतौर पर, डेटा के पहले 256 बाइट्स ही महत्वपूर्ण होते हैं।

तो, फ़ाइल से पहले (ऊपर) 256 बाइट्स पढ़ें और इसे पास करें FindMimeFromData


6
यह विधि कितनी विश्वसनीय है?
जॉन Bubriski

22
के अनुसार stackoverflow.com/questions/4833113/... , कि समारोह तो मैं नहीं लगता है कि यह विश्वसनीय है करते हैं, केवल 26 प्रकार निर्धारित करने के लिए सक्षम है। उदाहरण के लिए * .docx 'फ़ाइल' अनुप्रयोग / x-zip-संकुचित 'के रूप में निर्धारित की जाती है।
मोनसिग्नोर

54
मुझे लगता है कि क्योंकि docx जाहिरा तौर पर एक ज़िप फ़ाइल है।
निक डेवर्क्स

27
Docx है एक ज़िप फ़ाइल, लेकिन .docx के लिए माइम प्रकार "application / vnd.openxmlformats-officedocument.wordprocessingml.document" है। हालांकि यह बाइनरी-ओनली परीक्षा से निर्धारित किया जा सकता है, यह शायद इसे करने का सबसे कुशल तरीका नहीं है, और ज्यादातर मामलों में आपको पहले 256 बाइट्स से अधिक में पढ़ना होगा।
ब्रेनस्ल्गस83

172

मैंने अंत में urlmon.dll का उपयोग किया। मैंने सोचा कि एक आसान तरीका होगा लेकिन यह काम करता है। मुझे किसी और की मदद करने के लिए कोड शामिल है और अगर मुझे इसकी आवश्यकता है तो मुझे इसे फिर से खोजने की अनुमति दें।

using System.Runtime.InteropServices;

...

    [DllImport(@"urlmon.dll", CharSet = CharSet.Auto)]
    private extern static System.UInt32 FindMimeFromData(
        System.UInt32 pBC,
        [MarshalAs(UnmanagedType.LPStr)] System.String pwzUrl,
        [MarshalAs(UnmanagedType.LPArray)] byte[] pBuffer,
        System.UInt32 cbSize,
        [MarshalAs(UnmanagedType.LPStr)] System.String pwzMimeProposed,
        System.UInt32 dwMimeFlags,
        out System.UInt32 ppwzMimeOut,
        System.UInt32 dwReserverd
    );

    public static string getMimeFromFile(string filename)
    {
        if (!File.Exists(filename))
            throw new FileNotFoundException(filename + " not found");

        byte[] buffer = new byte[256];
        using (FileStream fs = new FileStream(filename, FileMode.Open))
        {
            if (fs.Length >= 256)
                fs.Read(buffer, 0, 256);
            else
                fs.Read(buffer, 0, (int)fs.Length);
        }
        try
        {
            System.UInt32 mimetype;
            FindMimeFromData(0, null, buffer, 256, null, 0, out mimetype, 0);
            System.IntPtr mimeTypePtr = new IntPtr(mimetype);
            string mime = Marshal.PtrToStringUni(mimeTypePtr);
            Marshal.FreeCoTaskMem(mimeTypePtr);
            return mime;
        }
        catch (Exception e)
        {
            return "unknown/unknown";
        }
    }

3
शायद रजिस्ट्री में जो भी मैप किया गया है।
मईकुर्रे


6
: जब इस मुद्दे को Windows 8 पर IIS में यह होस्टिंग pinvoke.net पर कार्यान्वयन (जो सूक्ष्म अंतर है) का उपयोग कर हल मैं इस कोड के साथ कोई समस्या हुई थी pinvoke.net/default.aspx/urlmon.findmimefromdata
Rohland

2
मैं IIS 7 के साथ इस कोड का परीक्षण कर रहा हूं और यह मेरे लिए काम नहीं कर रहा है। मेरे पास एक CSV फ़ाइल है जिसका मैं परीक्षण कर रहा हूं। मैं CSV (.png, .jpeg, आदि) के विस्तार को बदल रहा हूं और विस्तार (छवि / पीएनजी, छवि / जेपीईजी) के साथ mimetype परिवर्तन। मैं गलत हो सकता है, लेकिन यह मेरी समझ थी कि Urlmon.dll ने फ़ाइल के मेटाडेटा का उपयोग करके
mimetype को

2
64 बिट ऐप्स के लिए अच्छी तरह से काम नहीं करना, इसके बजाय यहाँ देखें: stackoverflow.com/questions/18358548/…
omer schleifer

99

मुझे एक हार्ड-कोडेड समाधान मिला है, मुझे आशा है कि मैं किसी की मदद करूंगा:

public static class MIMEAssistant
{
  private static readonly Dictionary<string, string> MIMETypesDictionary = new Dictionary<string, string>
  {
    {"ai", "application/postscript"},
    {"aif", "audio/x-aiff"},
    {"aifc", "audio/x-aiff"},
    {"aiff", "audio/x-aiff"},
    {"asc", "text/plain"},
    {"atom", "application/atom+xml"},
    {"au", "audio/basic"},
    {"avi", "video/x-msvideo"},
    {"bcpio", "application/x-bcpio"},
    {"bin", "application/octet-stream"},
    {"bmp", "image/bmp"},
    {"cdf", "application/x-netcdf"},
    {"cgm", "image/cgm"},
    {"class", "application/octet-stream"},
    {"cpio", "application/x-cpio"},
    {"cpt", "application/mac-compactpro"},
    {"csh", "application/x-csh"},
    {"css", "text/css"},
    {"dcr", "application/x-director"},
    {"dif", "video/x-dv"},
    {"dir", "application/x-director"},
    {"djv", "image/vnd.djvu"},
    {"djvu", "image/vnd.djvu"},
    {"dll", "application/octet-stream"},
    {"dmg", "application/octet-stream"},
    {"dms", "application/octet-stream"},
    {"doc", "application/msword"},
    {"docx","application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
    {"dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"},
    {"docm","application/vnd.ms-word.document.macroEnabled.12"},
    {"dotm","application/vnd.ms-word.template.macroEnabled.12"},
    {"dtd", "application/xml-dtd"},
    {"dv", "video/x-dv"},
    {"dvi", "application/x-dvi"},
    {"dxr", "application/x-director"},
    {"eps", "application/postscript"},
    {"etx", "text/x-setext"},
    {"exe", "application/octet-stream"},
    {"ez", "application/andrew-inset"},
    {"gif", "image/gif"},
    {"gram", "application/srgs"},
    {"grxml", "application/srgs+xml"},
    {"gtar", "application/x-gtar"},
    {"hdf", "application/x-hdf"},
    {"hqx", "application/mac-binhex40"},
    {"htm", "text/html"},
    {"html", "text/html"},
    {"ice", "x-conference/x-cooltalk"},
    {"ico", "image/x-icon"},
    {"ics", "text/calendar"},
    {"ief", "image/ief"},
    {"ifb", "text/calendar"},
    {"iges", "model/iges"},
    {"igs", "model/iges"},
    {"jnlp", "application/x-java-jnlp-file"},
    {"jp2", "image/jp2"},
    {"jpe", "image/jpeg"},
    {"jpeg", "image/jpeg"},
    {"jpg", "image/jpeg"},
    {"js", "application/x-javascript"},
    {"kar", "audio/midi"},
    {"latex", "application/x-latex"},
    {"lha", "application/octet-stream"},
    {"lzh", "application/octet-stream"},
    {"m3u", "audio/x-mpegurl"},
    {"m4a", "audio/mp4a-latm"},
    {"m4b", "audio/mp4a-latm"},
    {"m4p", "audio/mp4a-latm"},
    {"m4u", "video/vnd.mpegurl"},
    {"m4v", "video/x-m4v"},
    {"mac", "image/x-macpaint"},
    {"man", "application/x-troff-man"},
    {"mathml", "application/mathml+xml"},
    {"me", "application/x-troff-me"},
    {"mesh", "model/mesh"},
    {"mid", "audio/midi"},
    {"midi", "audio/midi"},
    {"mif", "application/vnd.mif"},
    {"mov", "video/quicktime"},
    {"movie", "video/x-sgi-movie"},
    {"mp2", "audio/mpeg"},
    {"mp3", "audio/mpeg"},
    {"mp4", "video/mp4"},
    {"mpe", "video/mpeg"},
    {"mpeg", "video/mpeg"},
    {"mpg", "video/mpeg"},
    {"mpga", "audio/mpeg"},
    {"ms", "application/x-troff-ms"},
    {"msh", "model/mesh"},
    {"mxu", "video/vnd.mpegurl"},
    {"nc", "application/x-netcdf"},
    {"oda", "application/oda"},
    {"ogg", "application/ogg"},
    {"pbm", "image/x-portable-bitmap"},
    {"pct", "image/pict"},
    {"pdb", "chemical/x-pdb"},
    {"pdf", "application/pdf"},
    {"pgm", "image/x-portable-graymap"},
    {"pgn", "application/x-chess-pgn"},
    {"pic", "image/pict"},
    {"pict", "image/pict"},
    {"png", "image/png"}, 
    {"pnm", "image/x-portable-anymap"},
    {"pnt", "image/x-macpaint"},
    {"pntg", "image/x-macpaint"},
    {"ppm", "image/x-portable-pixmap"},
    {"ppt", "application/vnd.ms-powerpoint"},
    {"pptx","application/vnd.openxmlformats-officedocument.presentationml.presentation"},
    {"potx","application/vnd.openxmlformats-officedocument.presentationml.template"},
    {"ppsx","application/vnd.openxmlformats-officedocument.presentationml.slideshow"},
    {"ppam","application/vnd.ms-powerpoint.addin.macroEnabled.12"},
    {"pptm","application/vnd.ms-powerpoint.presentation.macroEnabled.12"},
    {"potm","application/vnd.ms-powerpoint.template.macroEnabled.12"},
    {"ppsm","application/vnd.ms-powerpoint.slideshow.macroEnabled.12"},
    {"ps", "application/postscript"},
    {"qt", "video/quicktime"},
    {"qti", "image/x-quicktime"},
    {"qtif", "image/x-quicktime"},
    {"ra", "audio/x-pn-realaudio"},
    {"ram", "audio/x-pn-realaudio"},
    {"ras", "image/x-cmu-raster"},
    {"rdf", "application/rdf+xml"},
    {"rgb", "image/x-rgb"},
    {"rm", "application/vnd.rn-realmedia"},
    {"roff", "application/x-troff"},
    {"rtf", "text/rtf"},
    {"rtx", "text/richtext"},
    {"sgm", "text/sgml"},
    {"sgml", "text/sgml"},
    {"sh", "application/x-sh"},
    {"shar", "application/x-shar"},
    {"silo", "model/mesh"},
    {"sit", "application/x-stuffit"},
    {"skd", "application/x-koan"},
    {"skm", "application/x-koan"},
    {"skp", "application/x-koan"},
    {"skt", "application/x-koan"},
    {"smi", "application/smil"},
    {"smil", "application/smil"},
    {"snd", "audio/basic"},
    {"so", "application/octet-stream"},
    {"spl", "application/x-futuresplash"},
    {"src", "application/x-wais-source"},
    {"sv4cpio", "application/x-sv4cpio"},
    {"sv4crc", "application/x-sv4crc"},
    {"svg", "image/svg+xml"},
    {"swf", "application/x-shockwave-flash"},
    {"t", "application/x-troff"},
    {"tar", "application/x-tar"},
    {"tcl", "application/x-tcl"},
    {"tex", "application/x-tex"},
    {"texi", "application/x-texinfo"},
    {"texinfo", "application/x-texinfo"},
    {"tif", "image/tiff"},
    {"tiff", "image/tiff"},
    {"tr", "application/x-troff"},
    {"tsv", "text/tab-separated-values"},
    {"txt", "text/plain"},
    {"ustar", "application/x-ustar"},
    {"vcd", "application/x-cdlink"},
    {"vrml", "model/vrml"},
    {"vxml", "application/voicexml+xml"},
    {"wav", "audio/x-wav"},
    {"wbmp", "image/vnd.wap.wbmp"},
    {"wbmxl", "application/vnd.wap.wbxml"},
    {"wml", "text/vnd.wap.wml"},
    {"wmlc", "application/vnd.wap.wmlc"},
    {"wmls", "text/vnd.wap.wmlscript"},
    {"wmlsc", "application/vnd.wap.wmlscriptc"},
    {"wrl", "model/vrml"},
    {"xbm", "image/x-xbitmap"},
    {"xht", "application/xhtml+xml"},
    {"xhtml", "application/xhtml+xml"},
    {"xls", "application/vnd.ms-excel"},                        
    {"xml", "application/xml"},
    {"xpm", "image/x-xpixmap"},
    {"xsl", "application/xml"},
    {"xlsx","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
    {"xltx","application/vnd.openxmlformats-officedocument.spreadsheetml.template"},
    {"xlsm","application/vnd.ms-excel.sheet.macroEnabled.12"},
    {"xltm","application/vnd.ms-excel.template.macroEnabled.12"},
    {"xlam","application/vnd.ms-excel.addin.macroEnabled.12"},
    {"xlsb","application/vnd.ms-excel.sheet.binary.macroEnabled.12"},
    {"xslt", "application/xslt+xml"},
    {"xul", "application/vnd.mozilla.xul+xml"},
    {"xwd", "image/x-xwindowdump"},
    {"xyz", "chemical/x-xyz"},
    {"zip", "application/zip"}
  };

  public static string GetMIMEType(string fileName)
  {
    //get file extension
    string extension = Path.GetExtension(fileName).ToLowerInvariant();

    if (extension.Length > 0 && 
        MIMETypesDictionary.ContainsKey(extension.Remove(0, 1)))
    {
      return MIMETypesDictionary[extension.Remove(0, 1)];
    }
    return "unknown/unknown";
  }
}

58
यह हालांकि फ़ाइल नाम पर आधारित है। यह किसी के लिए उपयोगी हो सकता है, न कि ओपी, जो इसे फ़ाइल सामग्री द्वारा किया गया था।
मंड्रेको

4
इस सूची का एक सबसेट WebImage.ImageFormat को माइम प्रकार में मैप करने के लिए भी सुविधाजनक है। धन्यवाद!
डेरिक

8
अपने लक्ष्य के आधार पर, आप "अज्ञात / अज्ञात" के बजाय "एप्लिकेशन / ऑक्टेट-स्ट्रीम" वापस करना चाह सकते हैं।
निकोलस राउल

4
चूंकि मेरा संपादन अस्वीकार कर दिया गया था इसलिए मैं यहां पोस्ट करूंगा: विस्तार सभी निचले मामलों में होना चाहिए , या यह शब्दकोश में नहीं मिलेगा।
होवी

3
@ JalalAldeenSaa'd - StringComparer.OrdinalIgnoreCaseशब्दकोश निर्माता को उपयोग करने के लिए एक बेहतर फिक्स IMHO होगा । साधारण तुलना अपरिवर्तनीय की तुलना में तेज़ है, और आप इससे .ToLower()और इसके विविधताओं से छुटकारा पा लेंगे ।
इवलो स्लाव

87

संपादित करें: बस उपयोग करें माइम जासूस का

मैं दिए गए फ़ाइल के सही MIME प्रकार को निर्धारित करने के लिए बाइट सरणी अनुक्रमों का उपयोग करता हूं। इसका केवल फ़ाइल नाम के फ़ाइल एक्सटेंशन को देखने पर इसका लाभ यह है कि यदि कोई उपयोगकर्ता कुछ फ़ाइल प्रकार अपलोड प्रतिबंधों को बायपास करने के लिए एक फ़ाइल का नाम बदल देता है, तो फ़ाइल नाम एक्सटेंशन इसे पकड़ने में विफल होगा। दूसरी ओर, बाइट सरणी के माध्यम से फ़ाइल हस्ताक्षर प्राप्त करना इस शरारती व्यवहार को होने से रोक देगा।

यहाँ C # में एक उदाहरण दिया गया है:

public class MimeType
{
    private static readonly byte[] BMP = { 66, 77 };
    private static readonly byte[] DOC = { 208, 207, 17, 224, 161, 177, 26, 225 };
    private static readonly byte[] EXE_DLL = { 77, 90 };
    private static readonly byte[] GIF = { 71, 73, 70, 56 };
    private static readonly byte[] ICO = { 0, 0, 1, 0 };
    private static readonly byte[] JPG = { 255, 216, 255 };
    private static readonly byte[] MP3 = { 255, 251, 48 };
    private static readonly byte[] OGG = { 79, 103, 103, 83, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 };
    private static readonly byte[] PDF = { 37, 80, 68, 70, 45, 49, 46 };
    private static readonly byte[] PNG = { 137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82 };
    private static readonly byte[] RAR = { 82, 97, 114, 33, 26, 7, 0 };
    private static readonly byte[] SWF = { 70, 87, 83 };
    private static readonly byte[] TIFF = { 73, 73, 42, 0 };
    private static readonly byte[] TORRENT = { 100, 56, 58, 97, 110, 110, 111, 117, 110, 99, 101 };
    private static readonly byte[] TTF = { 0, 1, 0, 0, 0 };
    private static readonly byte[] WAV_AVI = { 82, 73, 70, 70 };
    private static readonly byte[] WMV_WMA = { 48, 38, 178, 117, 142, 102, 207, 17, 166, 217, 0, 170, 0, 98, 206, 108 };
    private static readonly byte[] ZIP_DOCX = { 80, 75, 3, 4 };

    public static string GetMimeType(byte[] file, string fileName)
    {

        string mime = "application/octet-stream"; //DEFAULT UNKNOWN MIME TYPE

        //Ensure that the filename isn't empty or null
        if (string.IsNullOrWhiteSpace(fileName))
        {
            return mime;
        }

        //Get the file extension
        string extension = Path.GetExtension(fileName) == null
                               ? string.Empty
                               : Path.GetExtension(fileName).ToUpper();

        //Get the MIME Type
        if (file.Take(2).SequenceEqual(BMP))
        {
            mime = "image/bmp";
        }
        else if (file.Take(8).SequenceEqual(DOC))
        {
            mime = "application/msword";
        }
        else if (file.Take(2).SequenceEqual(EXE_DLL))
        {
            mime = "application/x-msdownload"; //both use same mime type
        }
        else if (file.Take(4).SequenceEqual(GIF))
        {
            mime = "image/gif";
        }
        else if (file.Take(4).SequenceEqual(ICO))
        {
            mime = "image/x-icon";
        }
        else if (file.Take(3).SequenceEqual(JPG))
        {
            mime = "image/jpeg";
        }
        else if (file.Take(3).SequenceEqual(MP3))
        {
            mime = "audio/mpeg";
        }
        else if (file.Take(14).SequenceEqual(OGG))
        {
            if (extension == ".OGX")
            {
                mime = "application/ogg";
            }
            else if (extension == ".OGA")
            {
                mime = "audio/ogg";
            }
            else
            {
                mime = "video/ogg";
            }
        }
        else if (file.Take(7).SequenceEqual(PDF))
        {
            mime = "application/pdf";
        }
        else if (file.Take(16).SequenceEqual(PNG))
        {
            mime = "image/png";
        }
        else if (file.Take(7).SequenceEqual(RAR))
        {
            mime = "application/x-rar-compressed";
        }
        else if (file.Take(3).SequenceEqual(SWF))
        {
            mime = "application/x-shockwave-flash";
        }
        else if (file.Take(4).SequenceEqual(TIFF))
        {
            mime = "image/tiff";
        }
        else if (file.Take(11).SequenceEqual(TORRENT))
        {
            mime = "application/x-bittorrent";
        }
        else if (file.Take(5).SequenceEqual(TTF))
        {
            mime = "application/x-font-ttf";
        }
        else if (file.Take(4).SequenceEqual(WAV_AVI))
        {
            mime = extension == ".AVI" ? "video/x-msvideo" : "audio/x-wav";
        }
        else if (file.Take(16).SequenceEqual(WMV_WMA))
        {
            mime = extension == ".WMA" ? "audio/x-ms-wma" : "video/x-ms-wmv";
        }
        else if (file.Take(4).SequenceEqual(ZIP_DOCX))
        {
            mime = extension == ".DOCX" ? "application/vnd.openxmlformats-officedocument.wordprocessingml.document" : "application/x-zip-compressed";
        }

        return mime;
    }


}

ध्यान दें कि मैंने DOCX फाइल प्रकारों को अलग तरह से हैंडल किया है क्योंकि DOCX वास्तव में सिर्फ एक ज़िप फ़ाइल है। इस परिदृश्य में, मैं केवल फ़ाइल एक्सटेंशन की जांच करता हूं एक बार मैंने सत्यापित किया कि इसमें वह अनुक्रम है। यह उदाहरण कुछ लोगों के लिए पूर्ण से दूर है, लेकिन आप आसानी से अपना खुद का जोड़ सकते हैं।

यदि आप अधिक MIME प्रकार जोड़ना चाहते हैं, तो आप यहाँ से कई अलग-अलग फ़ाइल प्रकारों की बाइट सरणी अनुक्रम प्राप्त कर सकते हैं । इसके अलावा, यहां एक और अच्छा संसाधन है फ़ाइल हस्ताक्षर से संबंधित ।

यदि मैं बहुत बार ऐसा करता हूं तो अन्य सभी विफल रहता है, एक विशेष प्रकार की कई फ़ाइलों के माध्यम से कदम है जो मैं देख रहा हूं और फाइलों के बाइट अनुक्रम में एक पैटर्न की तलाश कर रहा हूं। अंत में, यह अभी भी बुनियादी सत्यापन है और इसका उपयोग फ़ाइल प्रकारों के निर्धारण के 100% प्रमाण के लिए नहीं किया जा सकता है।


1
धन्यवाद @ROFLwTIME - जब हम एक बाइट सरणी है, लेकिन कोई फ़ाइल नाम / विस्तार नहीं है, तो इसे संभालने के लिए मैंने इसे थोड़ा बढ़ाया है। (कुछ माइम प्रकारों के लिए निश्चित रूप से इसे डिफ़ॉल्ट रूप से करने की आवश्यकता होगी, या सही पहचान करने के लिए इसे और बढ़ाने की आवश्यकता है)। लेकिन अगर कोई मुझे कोड पोस्ट करना चाहे तो कृपया मुझे बताएं।
क्रिस

बाइट्स का उपयोग करने के लिए +1। अब एक विशेष प्रकार के माइम प्रकार के लिए बाइट्स की अपेक्षित संख्या भी ले सकते हैं ताकि इसका परीक्षण किया जा सके (256 का डिफ़ॉल्ट नहीं)। हालाँकि, मैं यहाँ एक संरचना के लिए जाऊँगा, विस्तार, बाइट्स और माइम / प्रकार के गुणों के साथ और शायद पूर्व-परिभाषित शब्‍दों का शब्दकोश भी रखूँगा। यह मुझे अंतहीन अगर-चेक की बचत करेगा
Ivaylo Slavov

2
इस दृष्टिकोण के साथ समस्या यह है कि, उदाहरण के लिए, "MZ" से शुरू होने वाली एक पाठ फ़ाइल को एक .EXE फ़ाइल के रूप में व्याख्या की जाएगी। दूसरे शब्दों में, आपको कम से कम सभी मामलों में विस्तार पर विचार करना चाहिए, साथ ही झूठी सकारात्मकता से बचने के लिए लंबे हस्ताक्षर या प्रति-प्रारूप के आंकड़े भी।
नेस्टर सैंचेज़ ए।

1
@ संक्षेप में, मेरा मानना ​​है कि XLS के अंत में 0 बाइट है, जबकि DOC नहीं है, इसलिए पहले XLS की जाँच करें, फिर DOC की। XLSX / DOCX के लिए, वे एक ही हस्ताक्षर (ज़िप) साझा करते हैं, इसलिए उन लोगों को अलग करने के लिए आपको हेडर पढ़ने से अधिक गहराई तक जाने की आवश्यकता होगी। उदाहरण के लिए, XLSX फ़ाइलों में हेडर के पास स्ट्रिंग "xl / _rels / workbook.xml.rels" होता है जबकि DOCX फाइलों में हेडर के पास स्ट्रिंग "वर्ड / _rels / document.xml.rels" होता है। यह उन विशेष प्रकारों को आज़माने और अलग करने के कई तरीकों में से एक है और यह निश्चित रूप से 100% परिदृश्यों को कवर करने वाला नहीं है। (इसमें DOCX / XLSX फाइलों के साथ उदा। ज़िप फ़ाइल)
ROFLwTIME

7
हे लोगों। मैं कैसे जीथब में MimeDetective करने के लिए मूल FileTypeDetective को फोर्क कर रहा हूं। मुझे खुशी है कि अगर यह उपयोगी है। और iv ने डेवलपर ट्रेलमैक्स के साथ बात की। हमने MIT का लाइसेंस बदल दिया है!
मुराद नोफाल

36

यदि आप .NET फ्रेमवर्क 4.5 या इसके बाद के संस्करण का उपयोग कर रहे हैं, तो अब एक MimeMapping.GetMimeMapping (फ़ाइल नाम) विधि है जो पारित फ़ाइल नाम के लिए सही माइम मैपिंग के साथ एक स्ट्रिंग लौटाएगा। ध्यान दें कि यह फ़ाइल एक्सटेंशन का उपयोग करता है, न कि फ़ाइल में डेटा।

प्रलेखन http://msdn.microsoft.com/en-us/library/system.web.mimemapping.getmimemapping पर है


3
इसने मेरे लिए काम किया और इसने केवल एक लाइन कोड लिया। var mimetype = System.Web.MimeMapping.GetMimeMapping(<pathToFile>);
गैरी

50
यह मूल प्रश्न का उत्तर नहीं देता है "यदि फ़ाइल एक्सटेंशन गलत है या गायब है"। GetMimeMapping सिर्फ विस्तार और माइम प्रविष्टियों के एक स्थिर शब्दकोश का उपयोग करता है।
बैरी हागन

1
मुझे यह वर्ग बहुत उपयोगी लगता है :)
TeYoU

1
.Net-core में उपलब्ध नहीं है। इसके बजाय आप उपयोग कर सकते हैं: स्ट्रिंग सामग्री टाइप; नई FileExtensionContentTypeProvider ()। TryGetContentType (फ़ाइल नाम, सामग्री से बाहर); contentType = contentType ?? "application / ओकटेट धारा";
जॉन पैनकोविज़

2
आम तौर पर, मैं एक जवाब नीचे नहीं है, लेकिन इस भ्रामक जवाब के रूप में, मैंने ऐसा किया। फ़ाइल नाम एक्सटेंशन पर भरोसा नहीं करने के बारे में सवाल कहता है
अंजनी

26

आप रजिस्ट्री में भी देख सकते हैं।

    using System.IO;
    using Microsoft.Win32;

    string GetMimeType(FileInfo fileInfo)
    {
        string mimeType = "application/unknown";

        RegistryKey regKey = Registry.ClassesRoot.OpenSubKey(
            fileInfo.Extension.ToLower()
            );

        if(regKey != null)
        {
            object contentType = regKey.GetValue("Content Type");

            if(contentType != null)
                mimeType = contentType.ToString();
        }

        return mimeType;
    }

MIMEs के डेटाबेस में टैप करने का एक तरीका या दूसरा तरीका - चाहे वे एक्सटेंशन से मैप किए गए हों या मैजिक नंबर कुछ तुच्छ हो - विंडोज़ रजिस्ट्री एक ऐसी जगह है। एक प्लेटफ़ॉर्म स्वतंत्र समाधान के लिए हालांकि किसी को इस DB को कोड के साथ (या एक स्टैंडअलोन लाइब्रेरी के रूप में) शिप करना होगा।


1
@ रब्बी भले ही प्रश्न सामग्री को दर्ज करने और विस्तार न करने के लिए विशिष्ट था, फिर भी यह उत्तर अन्य लोगों (जैसे स्वयं) के लिए उपयोगी हो सकता है, जो इससे गुजर रहे हैं। यहां तक ​​कि अगर इस तरह का उत्तर स्वीकार किए जाने की संभावना नहीं है, तो भी जानकारी होना अच्छा है।
ब्रेनस्ल्गस83

5
क्या यह केवल फ़ाइल नाम के विस्तार के आधार पर माइम नहीं मिलता है? क्या होगा अगर फ़ाइल एक .docx थी और कुछ विदूषक ने इसका नाम बदलकर .doc करने का फैसला किया? आपको निश्चित रूप से गलत माइम-प्रकार मिलता है।
15

8
@kolin, आप बिल्कुल सही हैं, लेकिन जैसा कि कहा जाता है "इसे बेवकूफ सबूत बनाएं और कोई सिर्फ एक बेहतर बेवकूफ बना देगा।" :)
सेर्गेई

जब Windows Azure वेब भूमिका या किसी अन्य होस्ट के साथ काम कर रहा है जो सीमित ट्रस्ट में आपका ऐप चलाता है - यह मत भूलो कि आपको रजिस्ट्री तक पहुंचने की अनुमति नहीं दी जाएगी। एनीकी के जवाब की तरह ट्राई-कैच-फॉर-रजिस्ट्री और इन-मेमोरी डिक्शनरी का संयोजन एक अच्छे समाधान की तरह दिखता है, जिसमें दोनों हैं।
ओग्यान दिमित्रोव

8

मैं एक संकर समाधान का उपयोग करता हूं:

    using System.Runtime.InteropServices;

    [DllImport (@"urlmon.dll", CharSet = CharSet.Auto)]
    private extern static System.UInt32 FindMimeFromData(
        System.UInt32 pBC, 
        [MarshalAs(UnmanagedType.LPStr)] System.String pwzUrl,
        [MarshalAs(UnmanagedType.LPArray)] byte[] pBuffer,
        System.UInt32 cbSize,
        [MarshalAs(UnmanagedType.LPStr)] System.String pwzMimeProposed,
        System.UInt32 dwMimeFlags,
        out System.UInt32 ppwzMimeOut,
        System.UInt32 dwReserverd
    );

    private string GetMimeFromRegistry (string Filename)
    {
        string mime = "application/octetstream";
        string ext = System.IO.Path.GetExtension(Filename).ToLower();
        Microsoft.Win32.RegistryKey rk = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(ext);
        if (rk != null && rk.GetValue("Content Type") != null)
            mime = rk.GetValue("Content Type").ToString();
        return mime;
    }

    public string GetMimeTypeFromFileAndRegistry (string filename)
    {
        if (!File.Exists(filename))
        {
           return GetMimeFromRegistry (filename);
        }

        byte[] buffer = new byte[256];

        using (FileStream fs = new FileStream(filename, FileMode.Open))
        {
            if (fs.Length >= 256)
                fs.Read(buffer, 0, 256);
            else
                fs.Read(buffer, 0, (int)fs.Length);
        }

        try
        {            
            System.UInt32 mimetype;

            FindMimeFromData(0, null, buffer, 256, null, 0, out mimetype, 0);

            System.IntPtr mimeTypePtr = new IntPtr(mimetype);

            string mime = Marshal.PtrToStringUni(mimeTypePtr);

            Marshal.FreeCoTaskMem(mimeTypePtr);

            if (string.IsNullOrWhiteSpace (mime) || 
                mime =="text/plain" || mime == "application/octet-stream")                    
            {
                return GetMimeFromRegistry (filename);
            }

            return mime;
        }
        catch (Exception e)
        {
            return GetMimeFromRegistry (filename);
        }
    }

1
कोड के लिए धन्यवाद। यह आंशिक रूप से काम किया। "डॉक" और "टिफ" फाइल दोनों के लिए यह "एप्लीकेशन / ऑक्टेट-स्ट्रीम" लौटाता है। क्या कोई अन्य विकल्प उपलब्ध हैं।
प्रणव शाह

उपरोक्त एक्सटेंशन शब्दकोश और urlmon का एक संकर समाधान देखना साफ-सुथरा होगा।
BrainSlugs83

@PranavShah, ध्यान दें कि सर्वर के माइम-प्रकार (रजिस्ट्री लुकअप द्वारा लौटाए गए) का ज्ञान सर्वर पर किस सॉफ़्टवेयर को स्थापित किया गया है। एक बुनियादी विंडोज़ इंस्टॉलेशन या एक समर्पित वेब सर्वर को 3-पार्टी सॉफ़्टवेयर के माइम-प्रकार को जानने के लिए विश्वसनीय नहीं होना चाहिए जो कि ज़रूरत से ज़्यादा स्थापित नहीं है। फिर भी, यह पता होना चाहिए कि .docफाइल क्या है।
Ivaylo Slavov

6

HeyRed.Mime.MimeGuesser.GuessMimeType यदि आप अपने ASP.NET समाधान को गैर-विंडोज़ वातावरण पर होस्ट करना चाहते हैं, तो Nuget अंतिम समाधान होगा।

फ़ाइल एक्सटेंशन मैपिंग बहुत असुरक्षित है। यदि कोई हमलावर अमान्य एक्सटेंशन अपलोड करता है, तो एक मैपिंग शब्दकोश। उदा। निष्पादनयोग्य को .jpg फ़ाइलों के अंदर वितरित करने की अनुमति देता है। इसलिए, वास्तविक सामग्री-प्रकार जानने के लिए हमेशा एक सामग्री-सूँघने वाली लाइब्रेरी का उपयोग करें।

 public  static string MimeTypeFrom(byte[] dataBytes, string fileName)
 {
        var contentType = HeyRed.Mime.MimeGuesser.GuessMimeType(dataBytes);
        if (string.IsNullOrEmpty(contentType))
        {
            return HeyRed.Mime.MimeTypesMap.GetMimeType(fileName);
        }
  return contentType;

1
अब तक, सर्वश्रेष्ठ पुस्तकालय मैंने कोशिश की है। मेरे फ़ोल्डर में रखी गई प्रत्येक फ़ाइल के लिए सामग्री प्रकार मिला। + .net कोर समर्थन!
टीएस

3

मुझे लगता है कि सही उत्तर स्टीव मॉर्गन और सेर्गेई के उत्तरों का संयोजन है। इंटरनेट एक्सप्लोरर यह कैसे करता है। पिनवोक कॉल FindMimeFromDataकेवल 26 हार्ड-कोडेड माइम प्रकारों के लिए काम करता है। इसके अलावा, यह अस्पष्ट माइम प्रकार (जैसे text/plainया) देगाapplication/octet-stream ) देगा भले ही अधिक विशिष्ट, अधिक उपयुक्त माइम प्रकार मौजूद हो। यदि यह एक अच्छा माइम प्रकार देने में विफल रहता है, तो आप अधिक विशिष्ट माइम प्रकार के लिए रजिस्ट्री पर जा सकते हैं। सर्वर रजिस्ट्री में अप-टू-डेट माइम प्रकार हो सकते हैं।

इसका संदर्भ लें: http://msdn.microsoft.com/en-us/library/ms775147(VS.858.bx


3

यह वर्ग 3 अलग-अलग तरीकों से कोशिश करने के लिए पिछले उत्तरों का उपयोग करता है: एक्सटेंशन, FindMimeFromData API और रजिस्ट्री का उपयोग करके आधारित।

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;

using Microsoft.Win32;

namespace YourNamespace
{
    public static class MimeTypeParser
    {
        [DllImport(@"urlmon.dll", CharSet = CharSet.Auto)]
        private extern static System.UInt32 FindMimeFromData(
                System.UInt32 pBC,
                [MarshalAs(UnmanagedType.LPStr)] System.String pwzUrl,
                [MarshalAs(UnmanagedType.LPArray)] byte[] pBuffer,
                System.UInt32 cbSize,
                [MarshalAs(UnmanagedType.LPStr)] System.String pwzMimeProposed,
                System.UInt32 dwMimeFlags,
                out System.UInt32 ppwzMimeOut,
                System.UInt32 dwReserverd
        );

        public static string GetMimeType(string sFilePath)
        {
            string sMimeType = GetMimeTypeFromList(sFilePath);

            if (String.IsNullOrEmpty(sMimeType))
            {
                sMimeType = GetMimeTypeFromFile(sFilePath);

                if (String.IsNullOrEmpty(sMimeType))
                {
                    sMimeType = GetMimeTypeFromRegistry(sFilePath);
                }
            }

            return sMimeType;
        }

        public static string GetMimeTypeFromList(string sFileNameOrPath)
        {
            string sMimeType = null;
            string sExtensionWithoutDot = Path.GetExtension(sFileNameOrPath).Substring(1).ToLower();

            if (!String.IsNullOrEmpty(sExtensionWithoutDot) && spDicMIMETypes.ContainsKey(sExtensionWithoutDot))
            {
                sMimeType = spDicMIMETypes[sExtensionWithoutDot];
            }

            return sMimeType;
        }

        public static string GetMimeTypeFromRegistry(string sFileNameOrPath)
        {
            string sMimeType = null;
            string sExtension = Path.GetExtension(sFileNameOrPath).ToLower();
            RegistryKey pKey = Registry.ClassesRoot.OpenSubKey(sExtension);

            if (pKey != null && pKey.GetValue("Content Type") != null)
            {
                sMimeType = pKey.GetValue("Content Type").ToString();
            }

            return sMimeType;
        }

        public static string GetMimeTypeFromFile(string sFilePath)
        {
            string sMimeType = null;

            if (File.Exists(sFilePath))
            {
                byte[] abytBuffer = new byte[256];

                using (FileStream pFileStream = new FileStream(sFilePath, FileMode.Open))
                {
                    if (pFileStream.Length >= 256)
                    {
                        pFileStream.Read(abytBuffer, 0, 256);
                    }
                    else
                    {
                        pFileStream.Read(abytBuffer, 0, (int)pFileStream.Length);
                    }
                }

                try
                {
                    UInt32 unMimeType;

                    FindMimeFromData(0, null, abytBuffer, 256, null, 0, out unMimeType, 0);

                    IntPtr pMimeType = new IntPtr(unMimeType);
                    string sMimeTypeFromFile = Marshal.PtrToStringUni(pMimeType);

                    Marshal.FreeCoTaskMem(pMimeType);

                    if (!String.IsNullOrEmpty(sMimeTypeFromFile) && sMimeTypeFromFile != "text/plain" && sMimeTypeFromFile != "application/octet-stream")
                    {
                        sMimeType = sMimeTypeFromFile;
                    }
                }
                catch {}
            }

            return sMimeType;
        }

        private static readonly Dictionary<string, string> spDicMIMETypes = new Dictionary<string, string>
        {
            {"ai", "application/postscript"},
            {"aif", "audio/x-aiff"},
            {"aifc", "audio/x-aiff"},
            {"aiff", "audio/x-aiff"},
            {"asc", "text/plain"},
            {"atom", "application/atom+xml"},
            {"au", "audio/basic"},
            {"avi", "video/x-msvideo"},
            {"bcpio", "application/x-bcpio"},
            {"bin", "application/octet-stream"},
            {"bmp", "image/bmp"},
            {"cdf", "application/x-netcdf"},
            {"cgm", "image/cgm"},
            {"class", "application/octet-stream"},
            {"cpio", "application/x-cpio"},
            {"cpt", "application/mac-compactpro"},
            {"csh", "application/x-csh"},
            {"css", "text/css"},
            {"dcr", "application/x-director"},
            {"dif", "video/x-dv"},
            {"dir", "application/x-director"},
            {"djv", "image/vnd.djvu"},
            {"djvu", "image/vnd.djvu"},
            {"dll", "application/octet-stream"},
            {"dmg", "application/octet-stream"},
            {"dms", "application/octet-stream"},
            {"doc", "application/msword"},
            {"docx","application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
            {"dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"},
            {"docm","application/vnd.ms-word.document.macroEnabled.12"},
            {"dotm","application/vnd.ms-word.template.macroEnabled.12"},
            {"dtd", "application/xml-dtd"},
            {"dv", "video/x-dv"},
            {"dvi", "application/x-dvi"},
            {"dxr", "application/x-director"},
            {"eps", "application/postscript"},
            {"etx", "text/x-setext"},
            {"exe", "application/octet-stream"},
            {"ez", "application/andrew-inset"},
            {"gif", "image/gif"},
            {"gram", "application/srgs"},
            {"grxml", "application/srgs+xml"},
            {"gtar", "application/x-gtar"},
            {"hdf", "application/x-hdf"},
            {"hqx", "application/mac-binhex40"},
            {"htc", "text/x-component"},
            {"htm", "text/html"},
            {"html", "text/html"},
            {"ice", "x-conference/x-cooltalk"},
            {"ico", "image/x-icon"},
            {"ics", "text/calendar"},
            {"ief", "image/ief"},
            {"ifb", "text/calendar"},
            {"iges", "model/iges"},
            {"igs", "model/iges"},
            {"jnlp", "application/x-java-jnlp-file"},
            {"jp2", "image/jp2"},
            {"jpe", "image/jpeg"},
            {"jpeg", "image/jpeg"},
            {"jpg", "image/jpeg"},
            {"js", "application/x-javascript"},
            {"kar", "audio/midi"},
            {"latex", "application/x-latex"},
            {"lha", "application/octet-stream"},
            {"lzh", "application/octet-stream"},
            {"m3u", "audio/x-mpegurl"},
            {"m4a", "audio/mp4a-latm"},
            {"m4b", "audio/mp4a-latm"},
            {"m4p", "audio/mp4a-latm"},
            {"m4u", "video/vnd.mpegurl"},
            {"m4v", "video/x-m4v"},
            {"mac", "image/x-macpaint"},
            {"man", "application/x-troff-man"},
            {"mathml", "application/mathml+xml"},
            {"me", "application/x-troff-me"},
            {"mesh", "model/mesh"},
            {"mid", "audio/midi"},
            {"midi", "audio/midi"},
            {"mif", "application/vnd.mif"},
            {"mov", "video/quicktime"},
            {"movie", "video/x-sgi-movie"},
            {"mp2", "audio/mpeg"},
            {"mp3", "audio/mpeg"},
            {"mp4", "video/mp4"},
            {"mpe", "video/mpeg"},
            {"mpeg", "video/mpeg"},
            {"mpg", "video/mpeg"},
            {"mpga", "audio/mpeg"},
            {"ms", "application/x-troff-ms"},
            {"msh", "model/mesh"},
            {"mxu", "video/vnd.mpegurl"},
            {"nc", "application/x-netcdf"},
            {"oda", "application/oda"},
            {"ogg", "application/ogg"},
            {"pbm", "image/x-portable-bitmap"},
            {"pct", "image/pict"},
            {"pdb", "chemical/x-pdb"},
            {"pdf", "application/pdf"},
            {"pgm", "image/x-portable-graymap"},
            {"pgn", "application/x-chess-pgn"},
            {"pic", "image/pict"},
            {"pict", "image/pict"},
            {"png", "image/png"}, 
            {"pnm", "image/x-portable-anymap"},
            {"pnt", "image/x-macpaint"},
            {"pntg", "image/x-macpaint"},
            {"ppm", "image/x-portable-pixmap"},
            {"ppt", "application/vnd.ms-powerpoint"},
            {"pptx","application/vnd.openxmlformats-officedocument.presentationml.presentation"},
            {"potx","application/vnd.openxmlformats-officedocument.presentationml.template"},
            {"ppsx","application/vnd.openxmlformats-officedocument.presentationml.slideshow"},
            {"ppam","application/vnd.ms-powerpoint.addin.macroEnabled.12"},
            {"pptm","application/vnd.ms-powerpoint.presentation.macroEnabled.12"},
            {"potm","application/vnd.ms-powerpoint.template.macroEnabled.12"},
            {"ppsm","application/vnd.ms-powerpoint.slideshow.macroEnabled.12"},
            {"ps", "application/postscript"},
            {"qt", "video/quicktime"},
            {"qti", "image/x-quicktime"},
            {"qtif", "image/x-quicktime"},
            {"ra", "audio/x-pn-realaudio"},
            {"ram", "audio/x-pn-realaudio"},
            {"ras", "image/x-cmu-raster"},
            {"rdf", "application/rdf+xml"},
            {"rgb", "image/x-rgb"},
            {"rm", "application/vnd.rn-realmedia"},
            {"roff", "application/x-troff"},
            {"rtf", "text/rtf"},
            {"rtx", "text/richtext"},
            {"sgm", "text/sgml"},
            {"sgml", "text/sgml"},
            {"sh", "application/x-sh"},
            {"shar", "application/x-shar"},
            {"silo", "model/mesh"},
            {"sit", "application/x-stuffit"},
            {"skd", "application/x-koan"},
            {"skm", "application/x-koan"},
            {"skp", "application/x-koan"},
            {"skt", "application/x-koan"},
            {"smi", "application/smil"},
            {"smil", "application/smil"},
            {"snd", "audio/basic"},
            {"so", "application/octet-stream"},
            {"spl", "application/x-futuresplash"},
            {"src", "application/x-wais-source"},
            {"sv4cpio", "application/x-sv4cpio"},
            {"sv4crc", "application/x-sv4crc"},
            {"svg", "image/svg+xml"},
            {"swf", "application/x-shockwave-flash"},
            {"t", "application/x-troff"},
            {"tar", "application/x-tar"},
            {"tcl", "application/x-tcl"},
            {"tex", "application/x-tex"},
            {"texi", "application/x-texinfo"},
            {"texinfo", "application/x-texinfo"},
            {"tif", "image/tiff"},
            {"tiff", "image/tiff"},
            {"tr", "application/x-troff"},
            {"tsv", "text/tab-separated-values"},
            {"txt", "text/plain"},
            {"ustar", "application/x-ustar"},
            {"vcd", "application/x-cdlink"},
            {"vrml", "model/vrml"},
            {"vxml", "application/voicexml+xml"},
            {"wav", "audio/x-wav"},
            {"wbmp", "image/vnd.wap.wbmp"},
            {"wbmxl", "application/vnd.wap.wbxml"},
            {"wml", "text/vnd.wap.wml"},
            {"wmlc", "application/vnd.wap.wmlc"},
            {"wmls", "text/vnd.wap.wmlscript"},
            {"wmlsc", "application/vnd.wap.wmlscriptc"},
            {"wrl", "model/vrml"},
            {"xbm", "image/x-xbitmap"},
            {"xht", "application/xhtml+xml"},
            {"xhtml", "application/xhtml+xml"},
            {"xls", "application/vnd.ms-excel"},                                                
            {"xml", "application/xml"},
            {"xpm", "image/x-xpixmap"},
            {"xsl", "application/xml"},
            {"xlsx","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
            {"xltx","application/vnd.openxmlformats-officedocument.spreadsheetml.template"},
            {"xlsm","application/vnd.ms-excel.sheet.macroEnabled.12"},
            {"xltm","application/vnd.ms-excel.template.macroEnabled.12"},
            {"xlam","application/vnd.ms-excel.addin.macroEnabled.12"},
            {"xlsb","application/vnd.ms-excel.sheet.binary.macroEnabled.12"},
            {"xslt", "application/xslt+xml"},
            {"xul", "application/vnd.mozilla.xul+xml"},
            {"xwd", "image/x-xwindowdump"},
            {"xyz", "chemical/x-xyz"},
            {"zip", "application/zip"}
        };
    }
}

3
रजिस्ट्री के आसपास ट्राई-कैच को मत भूलना - आपको इसे सीमित मोड में एक्सेस करने की अनुमति नहीं दी जाएगी जो सीमित ट्रस्ट में एज़्योर वेब की भूमिका या सीमा ट्रस्ट के साथ हर दूसरे होस्ट के साथ है।
ओग्यान दिमित्रोव

2

मुझे यह एक उपयोगी लगा। VB.NET डेवलपर्स के लिए:

    Public Shared Function GetFromFileName(ByVal fileName As String) As String
        Return GetFromExtension(Path.GetExtension(fileName).Remove(0, 1))
    End Function

    Public Shared Function GetFromExtension(ByVal extension As String) As String
        If extension.StartsWith("."c) Then
            extension = extension.Remove(0, 1)
        End If

        If MIMETypesDictionary.ContainsKey(extension) Then
            Return MIMETypesDictionary(extension)
        End If

        Return "unknown/unknown"
    End Function

    Private Shared ReadOnly MIMETypesDictionary As New Dictionary(Of String, String)() From { _
         {"ai", "application/postscript"}, _
         {"aif", "audio/x-aiff"}, _
         {"aifc", "audio/x-aiff"}, _
         {"aiff", "audio/x-aiff"}, _
         {"asc", "text/plain"}, _
         {"atom", "application/atom+xml"}, _
         {"au", "audio/basic"}, _
         {"avi", "video/x-msvideo"}, _
         {"bcpio", "application/x-bcpio"}, _
         {"bin", "application/octet-stream"}, _
         {"bmp", "image/bmp"}, _
         {"cdf", "application/x-netcdf"}, _
         {"cgm", "image/cgm"}, _
         {"class", "application/octet-stream"}, _
         {"cpio", "application/x-cpio"}, _
         {"cpt", "application/mac-compactpro"}, _
         {"csh", "application/x-csh"}, _
         {"css", "text/css"}, _
         {"dcr", "application/x-director"}, _
         {"dif", "video/x-dv"}, _
         {"dir", "application/x-director"}, _
         {"djv", "image/vnd.djvu"}, _
         {"djvu", "image/vnd.djvu"}, _
         {"dll", "application/octet-stream"}, _
         {"dmg", "application/octet-stream"}, _
         {"dms", "application/octet-stream"}, _
         {"doc", "application/msword"}, _
         {"dtd", "application/xml-dtd"}, _
         {"dv", "video/x-dv"}, _
         {"dvi", "application/x-dvi"}, _
         {"dxr", "application/x-director"}, _
         {"eps", "application/postscript"}, _
         {"etx", "text/x-setext"}, _
         {"exe", "application/octet-stream"}, _
         {"ez", "application/andrew-inset"}, _
         {"gif", "image/gif"}, _
         {"gram", "application/srgs"}, _
         {"grxml", "application/srgs+xml"}, _
         {"gtar", "application/x-gtar"}, _
         {"hdf", "application/x-hdf"}, _
         {"hqx", "application/mac-binhex40"}, _
         {"htm", "text/html"}, _
         {"html", "text/html"}, _
         {"ice", "x-conference/x-cooltalk"}, _
         {"ico", "image/x-icon"}, _
         {"ics", "text/calendar"}, _
         {"ief", "image/ief"}, _
         {"ifb", "text/calendar"}, _
         {"iges", "model/iges"}, _
         {"igs", "model/iges"}, _
         {"jnlp", "application/x-java-jnlp-file"}, _
         {"jp2", "image/jp2"}, _
         {"jpe", "image/jpeg"}, _
         {"jpeg", "image/jpeg"}, _
         {"jpg", "image/jpeg"}, _
         {"js", "application/x-javascript"}, _
         {"kar", "audio/midi"}, _
         {"latex", "application/x-latex"}, _
         {"lha", "application/octet-stream"}, _
         {"lzh", "application/octet-stream"}, _
         {"m3u", "audio/x-mpegurl"}, _
         {"m4a", "audio/mp4a-latm"}, _
         {"m4b", "audio/mp4a-latm"}, _
         {"m4p", "audio/mp4a-latm"}, _
         {"m4u", "video/vnd.mpegurl"}, _
         {"m4v", "video/x-m4v"}, _
         {"mac", "image/x-macpaint"}, _
         {"man", "application/x-troff-man"}, _
         {"mathml", "application/mathml+xml"}, _
         {"me", "application/x-troff-me"}, _
         {"mesh", "model/mesh"}, _
         {"mid", "audio/midi"}, _
         {"midi", "audio/midi"}, _
         {"mif", "application/vnd.mif"}, _
         {"mov", "video/quicktime"}, _
         {"movie", "video/x-sgi-movie"}, _
         {"mp2", "audio/mpeg"}, _
         {"mp3", "audio/mpeg"}, _
         {"mp4", "video/mp4"}, _
         {"mpe", "video/mpeg"}, _
         {"mpeg", "video/mpeg"}, _
         {"mpg", "video/mpeg"}, _
         {"mpga", "audio/mpeg"}, _
         {"ms", "application/x-troff-ms"}, _
         {"msh", "model/mesh"}, _
         {"mxu", "video/vnd.mpegurl"}, _
         {"nc", "application/x-netcdf"}, _
         {"oda", "application/oda"}, _
         {"ogg", "application/ogg"}, _
         {"pbm", "image/x-portable-bitmap"}, _
         {"pct", "image/pict"}, _
         {"pdb", "chemical/x-pdb"}, _
         {"pdf", "application/pdf"}, _
         {"pgm", "image/x-portable-graymap"}, _
         {"pgn", "application/x-chess-pgn"}, _
         {"pic", "image/pict"}, _
         {"pict", "image/pict"}, _
         {"png", "image/png"}, _
         {"pnm", "image/x-portable-anymap"}, _
         {"pnt", "image/x-macpaint"}, _
         {"pntg", "image/x-macpaint"}, _
         {"ppm", "image/x-portable-pixmap"}, _
         {"ppt", "application/vnd.ms-powerpoint"}, _
         {"ps", "application/postscript"}, _
         {"qt", "video/quicktime"}, _
         {"qti", "image/x-quicktime"}, _
         {"qtif", "image/x-quicktime"}, _
         {"ra", "audio/x-pn-realaudio"}, _
         {"ram", "audio/x-pn-realaudio"}, _
         {"ras", "image/x-cmu-raster"}, _
         {"rdf", "application/rdf+xml"}, _
         {"rgb", "image/x-rgb"}, _
         {"rm", "application/vnd.rn-realmedia"}, _
         {"roff", "application/x-troff"}, _
         {"rtf", "text/rtf"}, _
         {"rtx", "text/richtext"}, _
         {"sgm", "text/sgml"}, _
         {"sgml", "text/sgml"}, _
         {"sh", "application/x-sh"}, _
         {"shar", "application/x-shar"}, _
         {"silo", "model/mesh"}, _
         {"sit", "application/x-stuffit"}, _
         {"skd", "application/x-koan"}, _
         {"skm", "application/x-koan"}, _
         {"skp", "application/x-koan"}, _
         {"skt", "application/x-koan"}, _
         {"smi", "application/smil"}, _
         {"smil", "application/smil"}, _
         {"snd", "audio/basic"}, _
         {"so", "application/octet-stream"}, _
         {"spl", "application/x-futuresplash"}, _
         {"src", "application/x-wais-source"}, _
         {"sv4cpio", "application/x-sv4cpio"}, _
         {"sv4crc", "application/x-sv4crc"}, _
         {"svg", "image/svg+xml"}, _
         {"swf", "application/x-shockwave-flash"}, _
         {"t", "application/x-troff"}, _
         {"tar", "application/x-tar"}, _
         {"tcl", "application/x-tcl"}, _
         {"tex", "application/x-tex"}, _
         {"texi", "application/x-texinfo"}, _
         {"texinfo", "application/x-texinfo"}, _
         {"tif", "image/tiff"}, _
         {"tiff", "image/tiff"}, _
         {"tr", "application/x-troff"}, _
         {"tsv", "text/tab-separated-values"}, _
         {"txt", "text/plain"}, _
         {"ustar", "application/x-ustar"}, _
         {"vcd", "application/x-cdlink"}, _
         {"vrml", "model/vrml"}, _
         {"vxml", "application/voicexml+xml"}, _
         {"wav", "audio/x-wav"}, _
         {"wbmp", "image/vnd.wap.wbmp"}, _
         {"wbmxl", "application/vnd.wap.wbxml"}, _
         {"wml", "text/vnd.wap.wml"}, _
         {"wmlc", "application/vnd.wap.wmlc"}, _
         {"wmls", "text/vnd.wap.wmlscript"}, _
         {"wmlsc", "application/vnd.wap.wmlscriptc"}, _
         {"wrl", "model/vrml"}, _
         {"xbm", "image/x-xbitmap"}, _
         {"xht", "application/xhtml+xml"}, _
         {"xhtml", "application/xhtml+xml"}, _
         {"xls", "application/vnd.ms-excel"}, _
         {"xml", "application/xml"}, _
         {"xpm", "image/x-xpixmap"}, _
         {"xsl", "application/xml"}, _
         {"xslt", "application/xslt+xml"}, _
         {"xul", "application/vnd.mozilla.xul+xml"}, _
         {"xwd", "image/x-xwindowdump"}, _
         {"xyz", "chemical/x-xyz"}, _
         {"zip", "application/zip"} _
        }

4
ऐसा लग रहा है एक पुरानी सूची ... कोई .docx, .xlsx, आदि हो सकता है
JoelFan

कहीं ऑनलाइन सूची तो नहीं है? उपर्युक्त सूची थोड़ी अधिक पूर्ण दिखी, और उनमें से कुछ लापता पाए गए, यहाँ हैं: stackoverflow.com/questions/4212861/… - लेकिन ऐसा लगता है कि वहाँ एक वेब सेवा होनी चाहिए जहाँ आप सिर्फ एक फ़ाइल नाम और कुछ बाइट भेज सकते हैं वह भी जो सबसे अच्छा अनुमान लगा सकता है और बाकी लोगों का पता लगा सकता है ...
BrainSlugs83

मैं इसके लिए कॉन्फ़िगरेशन का उपयोग करता हूं, इसलिए मैं बिना किसी कोड की एक पंक्ति को बदलकर, माइम-प्रकार चुन सकता हूं और उन्हें तदनुसार संशोधित कर सकता हूं
Ivaylo Slavov

2

मैं उसी मुद्दे पर आया था और अंततः किरक बाउकॉम के समाधान के अपने स्वाद के लिए चुना, यहां पाया गया

मुझे ऐसा लगता है कि यह किसी के लिए ऑनलाइन लुक-अप सेवा लिखने का अवसर है।

वैसे भी, आशा है कि यह मदद करता है।


2

अगर कोई इसके लिए तैयार था, तो वे उत्कृष्ट पर्ल मॉड्यूल फाइल को टाइप कर सकते थे :: टाइप । .NET करें। कोड में प्रत्येक फ़ाइल प्रकार या रेगेक्स मैचों के लिए फ़ाइल हेडर मैजिक नंबर लुक अप का एक सेट है।

यहाँ पर एक .NET फाइल टाइप लाइब्रेरी का पता लगाया जा रहा है http://filetypedetective.codeplex.com/ लेकिन यह फिलहाल छोटी संख्या की फाइलों का पता लगाता है।


2

यह उत्तर लेखक के उत्तर (रिचर्ड ग्रेले) की एक प्रति है, लेकिन रोहेल्ड की http://www. http://www.vvoke.net की ओर इशारा करते हुए टिप्पणी के आधार पर IIS 8 / win2012 (जहां फ़ंक्शन क्रैश होने वाले ऐप पूल का कारण होगा) पर मुद्दों को हल करने के लिए सुधार हुआ है । /default.aspx/urlmon.findmimefromdata

using System.Runtime.InteropServices;

...

public static string GetMimeFromFile(string filename)
{

    if (!File.Exists(filename))
        throw new FileNotFoundException(filename + " not found");

    const int maxContent = 256;

    var buffer = new byte[maxContent];
    using (var fs = new FileStream(filename, FileMode.Open))
    {
        if (fs.Length >= maxContent)
            fs.Read(buffer, 0, maxContent);
        else
            fs.Read(buffer, 0, (int) fs.Length);
    }

    var mimeTypePtr = IntPtr.Zero;
    try
    {
        var result = FindMimeFromData(IntPtr.Zero, null, buffer, maxContent, null, 0, out mimeTypePtr, 0);
        if (result != 0)
        {
            Marshal.FreeCoTaskMem(mimeTypePtr);
            throw Marshal.GetExceptionForHR(result);
        }

        var mime = Marshal.PtrToStringUni(mimeTypePtr);
        Marshal.FreeCoTaskMem(mimeTypePtr);
        return mime;
    }
    catch (Exception e)
    {
        if (mimeTypePtr != IntPtr.Zero)
        {
            Marshal.FreeCoTaskMem(mimeTypePtr);
        }
        return "unknown/unknown";
    }
}

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

अच्छा C + P सक्षम उत्तर। चर्स
मेमेवेदर

2

@Steve Morgan और @Richard Gourlay यह एक महान समाधान है, इसके लिए धन्यवाद। एक छोटी खामी यह है कि जब किसी फाइल में बाइट्स की संख्या 255 या उससे कम होती है, तो माइम प्रकार कभी-कभी "एप्लिकेशन / ऑक्टेट-स्ट्रीम" प्राप्त करेगा, जो उन फाइलों के लिए थोड़ा गलत है, जो "टेक्स्ट / प्लेन" उपज की उम्मीद करेंगे। मैंने इस स्थिति के लिए आपकी मूल विधि को इस प्रकार अद्यतन किया है:

यदि फ़ाइल में बाइट्स की संख्या 255 से कम या बराबर है और घटाया गया माइम प्रकार "एप्लिकेशन / ऑक्टेट-स्ट्रीम" है, तो एक नया बाइट सरणी बनाएं जिसमें मूल फ़ाइल बाइट्स में कुल संख्या तक बार-बार दोहराया जाने वाला एन-बाइट शामिल हो। बाइट्स का => 256 है। फिर उस नए बाइट सरणी पर माइम-प्रकार को फिर से जांचें।

संशोधित विधि:

Imports System.Runtime.InteropServices

<DllImport("urlmon.dll", CharSet:=CharSet.Auto)> _
Private Shared Function FindMimeFromData(pBC As System.UInt32, <MarshalAs(UnmanagedType.LPStr)> pwzUrl As System.String, <MarshalAs(UnmanagedType.LPArray)> pBuffer As Byte(), cbSize As System.UInt32, <MarshalAs(UnmanagedType.LPStr)> pwzMimeProposed As System.String, dwMimeFlags As System.UInt32, _
ByRef ppwzMimeOut As System.UInt32, dwReserverd As System.UInt32) As System.UInt32
End Function
Private Function GetMimeType(ByVal f As FileInfo) As String
    'See http://stackoverflow.com/questions/58510/using-net-how-can-you-find-the-mime-type-of-a-file-based-on-the-file-signature
    Dim returnValue As String = ""
    Dim fileStream As FileStream = Nothing
    Dim fileStreamLength As Long = 0
    Dim fileStreamIsLessThanBByteSize As Boolean = False

    Const byteSize As Integer = 255
    Const bbyteSize As Integer = byteSize + 1

    Const ambiguousMimeType As String = "application/octet-stream"
    Const unknownMimeType As String = "unknown/unknown"

    Dim buffer As Byte() = New Byte(byteSize) {}
    Dim fnGetMimeTypeValue As New Func(Of Byte(), Integer, String)(
        Function(_buffer As Byte(), _bbyteSize As Integer) As String
            Dim _returnValue As String = ""
            Dim mimeType As UInt32 = 0
            FindMimeFromData(0, Nothing, _buffer, _bbyteSize, Nothing, 0, mimeType, 0)
            Dim mimeTypePtr As IntPtr = New IntPtr(mimeType)
            _returnValue = Marshal.PtrToStringUni(mimeTypePtr)
            Marshal.FreeCoTaskMem(mimeTypePtr)
            Return _returnValue
        End Function)

    If (f.Exists()) Then
        Try
            fileStream = New FileStream(f.FullName(), FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
            fileStreamLength = fileStream.Length()

            If (fileStreamLength >= bbyteSize) Then
                fileStream.Read(buffer, 0, bbyteSize)
            Else
                fileStreamIsLessThanBByteSize = True
                fileStream.Read(buffer, 0, CInt(fileStreamLength))
            End If

            returnValue = fnGetMimeTypeValue(buffer, bbyteSize)

            If (returnValue.Equals(ambiguousMimeType, StringComparison.OrdinalIgnoreCase) AndAlso fileStreamIsLessThanBByteSize AndAlso fileStreamLength > 0) Then
                'Duplicate the stream content until the stream length is >= bbyteSize to get a more deterministic mime type analysis.
                Dim currentBuffer As Byte() = buffer.Take(fileStreamLength).ToArray()
                Dim repeatCount As Integer = Math.Floor((bbyteSize / fileStreamLength) + 1)
                Dim bBufferList As List(Of Byte) = New List(Of Byte)
                While (repeatCount > 0)
                    bBufferList.AddRange(currentBuffer)
                    repeatCount -= 1
                End While
                Dim bbuffer As Byte() = bBufferList.Take(bbyteSize).ToArray()
                returnValue = fnGetMimeTypeValue(bbuffer, bbyteSize)
            End If
        Catch ex As Exception
            returnValue = unknownMimeType
        Finally
            If (fileStream IsNot Nothing) Then fileStream.Close()
        End Try
    End If
    Return returnValue
End Function

यह वह मुद्दा था जो मेरे पास था, और बाइट्स की नकल करने के लिए आपका विचार बहुत अच्छा था। मुझे इसे c # में लागू करना था, लेकिन फ़ाइल की लंबाई और फ़ाइल के पहले बाइट्स का उपयोग करने वाले बफर में, मैं सभी गुम बाइट्स पर पुनरावृति करने और फ़ाइल को दोहराने के लिए सरणी में बाइट्स की प्रतिलिपि बनाने में सक्षम था (i) बस आईडी से बाइट की प्रतिलिपि बनाई जो पहले सरणी में फ़ाइल की लंबाई थी)।
रिचर्ड ड्यूरे

1

IIS 7 या अधिक

इस कोड का उपयोग करें, लेकिन आपको सर्वर पर व्यवस्थापक होने की आवश्यकता है

public bool CheckMimeMapExtension(string fileExtension)
        {
            try
            {

                using (
                ServerManager serverManager = new ServerManager())
                {   
                    // connects to default app.config
                    var config = serverManager.GetApplicationHostConfiguration();
                    var staticContent = config.GetSection("system.webServer/staticContent");
                    var mimeMap = staticContent.GetCollection();

                    foreach (var mimeType in mimeMap)
                    {

                        if (((String)mimeType["fileExtension"]).Equals(fileExtension, StringComparison.OrdinalIgnoreCase))
                            return true;

                    }

                }
                return false;
            }
            catch (Exception ex)
            { 
                Console.WriteLine("An exception has occurred: \n{0}", ex.Message);
                Console.Read();
            }

            return false;

        }

स्पूफिंग के बारे में क्या?
टीएस

0

जब Windows Azure वेब भूमिका या किसी अन्य होस्ट के साथ काम कर रहा है जो सीमित ट्रस्ट में आपके ऐप को चलाता है, तो यह मत भूलो कि आपको रजिस्ट्री या अप्रबंधित कोड तक पहुंचने की अनुमति नहीं होगी। हाइब्रिड दृष्टिकोण - ट्राइ-कैच-फॉर-रजिस्ट्री और इन-मेमोरी डिक्शनरी का संयोजन एक अच्छा समाधान की तरह दिखता है जिसमें सब कुछ होता है।

मैं इसे करने के लिए इस कोड का उपयोग करता हूं:

public class DefaultMimeResolver : IMimeResolver
{
    private readonly IFileRepository _fileRepository;

    public DefaultMimeResolver(IFileRepository fileRepository)
    {
        _fileRepository = fileRepository;
    }

    [DllImport(@"urlmon.dll", CharSet = CharSet.Auto)]
    private static extern System.UInt32 FindMimeFromData(
        System.UInt32 pBC, [MarshalAs(UnmanagedType.LPStr)] System.String pwzUrl,
         [MarshalAs(UnmanagedType.LPArray)] byte[] pBuffer,
         System.UInt32 cbSize,
         [MarshalAs(UnmanagedType.LPStr)] System.String pwzMimeProposed,
         System.UInt32 dwMimeFlags,
         out System.UInt32 ppwzMimeOut,
         System.UInt32 dwReserverd);


    public string GetMimeTypeFromFileExtension(string fileExtension)
    {
        if (string.IsNullOrEmpty(fileExtension))
        {
            throw new ArgumentNullException("fileExtension");
        }

        string mimeType = GetMimeTypeFromList(fileExtension);

        if (String.IsNullOrEmpty(mimeType))
        {
            mimeType = GetMimeTypeFromRegistry(fileExtension);
        }

        return mimeType;
    }

    public string GetMimeTypeFromFile(string filePath)
    {
        if (string.IsNullOrEmpty(filePath))
        {
            throw new ArgumentNullException("filePath");
        }

        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException("File not found : ", filePath);
        }

        string mimeType = GetMimeTypeFromList(Path.GetExtension(filePath).ToLower());

        if (String.IsNullOrEmpty(mimeType))
        {
            mimeType = GetMimeTypeFromRegistry(Path.GetExtension(filePath).ToLower());

            if (String.IsNullOrEmpty(mimeType))
            {
                mimeType = GetMimeTypeFromFileInternal(filePath);
            }
        }

        return mimeType;
    }

    private string GetMimeTypeFromList(string fileExtension)
    {
        string mimeType = null;

        if (fileExtension.StartsWith("."))
        {
            fileExtension = fileExtension.TrimStart('.');
        }

        if (!String.IsNullOrEmpty(fileExtension) && _mimeTypes.ContainsKey(fileExtension))
        {
            mimeType = _mimeTypes[fileExtension];
        }

        return mimeType;
    }

    private string GetMimeTypeFromRegistry(string fileExtension)
    {
        string mimeType = null;
        try
        {
            RegistryKey key = Registry.ClassesRoot.OpenSubKey(fileExtension);

            if (key != null && key.GetValue("Content Type") != null)
            {
                mimeType = key.GetValue("Content Type").ToString();
            }
        }
        catch (Exception)
        {
            // Empty. When this code is running in limited mode accessing registry is not allowed.
        }

        return mimeType;
    }

    private string GetMimeTypeFromFileInternal(string filePath)
    {
        string mimeType = null;

        if (!File.Exists(filePath))
        {
            return null;
        }

        byte[] byteBuffer = new byte[256];

        using (FileStream fileStream = _fileRepository.Get(filePath))
        {
            if (fileStream.Length >= 256)
            {
                fileStream.Read(byteBuffer, 0, 256);
            }
            else
            {
                fileStream.Read(byteBuffer, 0, (int)fileStream.Length);
            }
        }

        try
        {
            UInt32 MimeTypeNum;

            FindMimeFromData(0, null, byteBuffer, 256, null, 0, out MimeTypeNum, 0);

            IntPtr mimeTypePtr = new IntPtr(MimeTypeNum);
            string mimeTypeFromFile = Marshal.PtrToStringUni(mimeTypePtr);

            Marshal.FreeCoTaskMem(mimeTypePtr);

            if (!String.IsNullOrEmpty(mimeTypeFromFile) && mimeTypeFromFile != "text/plain" && mimeTypeFromFile != "application/octet-stream")
            {
                mimeType = mimeTypeFromFile;
            }
        }
        catch
        {
            // Empty. 
        }

        return mimeType;
    }

    private readonly Dictionary<string, string> _mimeTypes = new Dictionary<string, string>
        {
            {"ai", "application/postscript"},
            {"aif", "audio/x-aiff"},
            {"aifc", "audio/x-aiff"},
            {"aiff", "audio/x-aiff"},
            {"asc", "text/plain"},
            {"atom", "application/atom+xml"},
            {"au", "audio/basic"},
            {"avi", "video/x-msvideo"},
            {"bcpio", "application/x-bcpio"},
            {"bin", "application/octet-stream"},
            {"bmp", "image/bmp"},
            {"cdf", "application/x-netcdf"},
            {"cgm", "image/cgm"},
            {"class", "application/octet-stream"},
            {"cpio", "application/x-cpio"},
            {"cpt", "application/mac-compactpro"},
            {"csh", "application/x-csh"},
            {"css", "text/css"},
            {"dcr", "application/x-director"},
            {"dif", "video/x-dv"},
            {"dir", "application/x-director"},
            {"djv", "image/vnd.djvu"},
            {"djvu", "image/vnd.djvu"},
            {"dll", "application/octet-stream"},
            {"dmg", "application/octet-stream"},
            {"dms", "application/octet-stream"},
            {"doc", "application/msword"},
            {"docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
            {"dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template"},
            {"docm", "application/vnd.ms-word.document.macroEnabled.12"},
            {"dotm", "application/vnd.ms-word.template.macroEnabled.12"},
            {"dtd", "application/xml-dtd"},
            {"dv", "video/x-dv"},
            {"dvi", "application/x-dvi"},
            {"dxr", "application/x-director"},
            {"eps", "application/postscript"},
            {"etx", "text/x-setext"},
            {"exe", "application/octet-stream"},
            {"ez", "application/andrew-inset"},
            {"gif", "image/gif"},
            {"gram", "application/srgs"},
            {"grxml", "application/srgs+xml"},
            {"gtar", "application/x-gtar"},
            {"hdf", "application/x-hdf"},
            {"hqx", "application/mac-binhex40"},
            {"htc", "text/x-component"},
            {"htm", "text/html"},
            {"html", "text/html"},
            {"ice", "x-conference/x-cooltalk"},
            {"ico", "image/x-icon"},
            {"ics", "text/calendar"},
            {"ief", "image/ief"},
            {"ifb", "text/calendar"},
            {"iges", "model/iges"},
            {"igs", "model/iges"},
            {"jnlp", "application/x-java-jnlp-file"},
            {"jp2", "image/jp2"},
            {"jpe", "image/jpeg"},
            {"jpeg", "image/jpeg"},
            {"jpg", "image/jpeg"},
            {"js", "application/x-javascript"},
            {"kar", "audio/midi"},
            {"latex", "application/x-latex"},
            {"lha", "application/octet-stream"},
            {"lzh", "application/octet-stream"},
            {"m3u", "audio/x-mpegurl"},
            {"m4a", "audio/mp4a-latm"},
            {"m4b", "audio/mp4a-latm"},
            {"m4p", "audio/mp4a-latm"},
            {"m4u", "video/vnd.mpegurl"},
            {"m4v", "video/x-m4v"},
            {"mac", "image/x-macpaint"},
            {"man", "application/x-troff-man"},
            {"mathml", "application/mathml+xml"},
            {"me", "application/x-troff-me"},
            {"mesh", "model/mesh"},
            {"mid", "audio/midi"},
            {"midi", "audio/midi"},
            {"mif", "application/vnd.mif"},
            {"mov", "video/quicktime"},
            {"movie", "video/x-sgi-movie"},
            {"mp2", "audio/mpeg"},
            {"mp3", "audio/mpeg"},
            {"mp4", "video/mp4"},
            {"mpe", "video/mpeg"},
            {"mpeg", "video/mpeg"},
            {"mpg", "video/mpeg"},
            {"mpga", "audio/mpeg"},
            {"ms", "application/x-troff-ms"},
            {"msh", "model/mesh"},
            {"mxu", "video/vnd.mpegurl"},
            {"nc", "application/x-netcdf"},
            {"oda", "application/oda"},
            {"ogg", "application/ogg"},
            {"pbm", "image/x-portable-bitmap"},
            {"pct", "image/pict"},
            {"pdb", "chemical/x-pdb"},
            {"pdf", "application/pdf"},
            {"pgm", "image/x-portable-graymap"},
            {"pgn", "application/x-chess-pgn"},
            {"pic", "image/pict"},
            {"pict", "image/pict"},
            {"png", "image/png"},
            {"pnm", "image/x-portable-anymap"},
            {"pnt", "image/x-macpaint"},
            {"pntg", "image/x-macpaint"},
            {"ppm", "image/x-portable-pixmap"},
            {"ppt", "application/vnd.ms-powerpoint"},
            {"pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
            {"potx", "application/vnd.openxmlformats-officedocument.presentationml.template"},
            {"ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow"},
            {"ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12"},
            {"pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12"},
            {"potm", "application/vnd.ms-powerpoint.template.macroEnabled.12"},
            {"ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12"},
            {"ps", "application/postscript"},
            {"qt", "video/quicktime"},
            {"qti", "image/x-quicktime"},
            {"qtif", "image/x-quicktime"},
            {"ra", "audio/x-pn-realaudio"},
            {"ram", "audio/x-pn-realaudio"},
            {"ras", "image/x-cmu-raster"},
            {"rdf", "application/rdf+xml"},
            {"rgb", "image/x-rgb"},
            {"rm", "application/vnd.rn-realmedia"},
            {"roff", "application/x-troff"},
            {"rtf", "text/rtf"},
            {"rtx", "text/richtext"},
            {"sgm", "text/sgml"},
            {"sgml", "text/sgml"},
            {"sh", "application/x-sh"},
            {"shar", "application/x-shar"},
            {"silo", "model/mesh"},
            {"sit", "application/x-stuffit"},
            {"skd", "application/x-koan"},
            {"skm", "application/x-koan"},
            {"skp", "application/x-koan"},
            {"skt", "application/x-koan"},
            {"smi", "application/smil"},
            {"smil", "application/smil"},
            {"snd", "audio/basic"},
            {"so", "application/octet-stream"},
            {"spl", "application/x-futuresplash"},
            {"src", "application/x-wais-source"},
            {"sv4cpio", "application/x-sv4cpio"},
            {"sv4crc", "application/x-sv4crc"},
            {"svg", "image/svg+xml"},
            {"swf", "application/x-shockwave-flash"},
            {"t", "application/x-troff"},
            {"tar", "application/x-tar"},
            {"tcl", "application/x-tcl"},
            {"tex", "application/x-tex"},
            {"texi", "application/x-texinfo"},
            {"texinfo", "application/x-texinfo"},
            {"tif", "image/tiff"},
            {"tiff", "image/tiff"},
            {"tr", "application/x-troff"},
            {"tsv", "text/tab-separated-values"},
            {"txt", "text/plain"},
            {"ustar", "application/x-ustar"},
            {"vcd", "application/x-cdlink"},
            {"vrml", "model/vrml"},
            {"vxml", "application/voicexml+xml"},
            {"wav", "audio/x-wav"},
            {"wbmp", "image/vnd.wap.wbmp"},
            {"wbmxl", "application/vnd.wap.wbxml"},
            {"wml", "text/vnd.wap.wml"},
            {"wmlc", "application/vnd.wap.wmlc"},
            {"wmls", "text/vnd.wap.wmlscript"},
            {"wmlsc", "application/vnd.wap.wmlscriptc"},
            {"wrl", "model/vrml"},
            {"xbm", "image/x-xbitmap"},
            {"xht", "application/xhtml+xml"},
            {"xhtml", "application/xhtml+xml"},
            {"xls", "application/vnd.ms-excel"},
            {"xml", "application/xml"},
            {"xpm", "image/x-xpixmap"},
            {"xsl", "application/xml"},
            {"xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
            {"xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template"},
            {"xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12"},
            {"xltm", "application/vnd.ms-excel.template.macroEnabled.12"},
            {"xlam", "application/vnd.ms-excel.addin.macroEnabled.12"},
            {"xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12"},
            {"xslt", "application/xslt+xml"},
            {"xul", "application/vnd.mozilla.xul+xml"},
            {"xwd", "image/x-xwindowdump"},
            {"xyz", "chemical/x-xyz"},
            {"zip", "application/zip"}
        };
}

मैं नीचे दिए गए वोट पर किसी भी टिप्पणी की ईमानदारी से सराहना करूंगा - मैं वास्तव में इस कोड के किसी भी संभावित गलत काम के बारे में सीखना चाहता हूं।
ओग्यान दिमित्रोव

जब आप GetMimeTypeFromFileInternal का उपयोग करते हैं, तो मुझे आपके कोड में कोई भी प्रयास नहीं करना चाहिए। तो, ऐसा लगता है कि डिफ़ॉल्ट रूप से आप केवल फ़ाइल एक्सटेंशन की जांच करते हैं, जो वास्तव में उपयोगी नहीं है यदि आप सुनिश्चित नहीं हैं, तो वास्तव में फ़ाइल के अंदर क्या है। और मैं अभी भी नहीं मिल सकता है, GetMimeTypeFromFileInternal लिमिटेड ट्रस्ट के साथ Azure में काम करता है? यदि नहीं, तो यह अभी भी कोड में क्यों है?
अलेक्जेंडर स्कोगोरोव

1
एक सीमित निष्पादन संदर्भ के मामले में, आप केवल सूची का उपयोग करने के लिए कोड को सीमित कर सकते हैं। हां, इससे अधिक एक्सटेंशन हैं, लेकिन केवल डेवलपर एप्लिकेशन के संदर्भ को जानता है और सूची में अधिक जोड़ सकता है। और सुनिश्चित करने के लिए एक ट्राइ-कैच अच्छा है।
ओग्यान दिमित्रोव

0

मैंने नेटोमैटिक्स से विनीस्टा माइमडेक्टर का उपयोग किया। आपके द्वारा खाता बनाने के बाद स्रोतों को मुफ्त में डाउनलोड किया जा सकता है: http://www.netomatix.com/Products/DocumentManagement/MimeDetector.aspx

MimeTypes g_MimeTypes = new MimeTypes("mime-types.xml");
sbyte [] fileData = null;

using (System.IO.FileStream srcFile = new System.IO.FileStream(strFile, System.IO.FileMode.Open))
{
    byte [] data = new byte[srcFile.Length];
    srcFile.Read(data, 0, (Int32)srcFile.Length);
    fileData = Winista.Mime.SupportUtil.ToSByteArray(data);
}

MimeType oMimeType = g_MimeTypes.GetMimeType(fileData);

यह यहां दिए गए एक अन्य प्रश्न का हिस्सा है: Urlmon.dll में FindMimeFromData पद्धति का विकल्प जो अधिक MIME प्रकार है मेरी राय में इस समस्या का सबसे अच्छा समाधान है।


0

मुझे इस कोड को चलाने की कई समस्याएं मिलीं:

UInt32 mimetype;
FindMimeFromData(0, null, buffer, 256, null, 0, out mimetype, 0);

यदि आप इसे x64 / Win10 के साथ चलाने का प्रयास करेंगे तो आपको मिलेगा

AccessViolationException "Attempted to read or write protected memory.
This is often an indication that other memory is corrupt"

इस पोस्ट के लिए धन्यवाद PtrToStringUni विंडोज़ 10 और @xanatos में काम नहीं करता है

मैंने x64 और .NET कोर 2.1 के तहत चलने के लिए अपने समाधान को संशोधित किया:

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

   string getMimeFromFile(byte[] fileSource)
   {
            byte[] buffer = new byte[256];
            using (Stream stream = new MemoryStream(fileSource))
            {
                if (stream.Length >= 256)
                    stream.Read(buffer, 0, 256);
                else
                    stream.Read(buffer, 0, (int)stream.Length);
            }

            try
            {
                IntPtr mimeTypePtr;
                FindMimeFromData(IntPtr.Zero, null, buffer, buffer.Length,
                    null, 0, out mimeTypePtr, 0);

                string mime = Marshal.PtrToStringUni(mimeTypePtr);
                Marshal.FreeCoTaskMem(mimeTypePtr);
                return mime;
            }
            catch (Exception ex)
            {
                return "unknown/unknown";
            }
   }

धन्यवाद


0

नमस्कार, मैंने Winista.MimeDetect प्रोजेक्ट को .net कोर / फ्रेमवर्क में उतारा जिसमें urlmon.dll फेल के साथ इसे उपयोग करने के लिए स्वतंत्र किया गया है: nuget पैकेज

   //init
   var mimeTypes = new MimeTypes();

   //usage by filepath
   var mimeType1 = mimeTypes.GetMimeTypeFromFile(filePath);

gihub कोड नमूना यहाँ गलत है github.com/GetoXs/MimeDetect । ओवरलोड नहींmimeTypes.GetMimeTypeFromFile(bytes);
टीएस

0

मैंने माइम प्रकार का सत्यापनकर्ता लिखा। कृपया इसे अपने साथ साझा करें।

private readonly Dictionary<string, byte[]> _mimeTypes = new Dictionary<string, byte[]>
    {
        {"image/jpeg", new byte[] {255, 216, 255}},
        {"image/jpg", new byte[] {255, 216, 255}},
        {"image/pjpeg", new byte[] {255, 216, 255}},
        {"image/apng", new byte[] {137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82}},
        {"image/png", new byte[] {137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82}},
        {"image/bmp", new byte[] {66, 77}},
        {"image/gif", new byte[] {71, 73, 70, 56}},
    };

private bool ValidateMimeType(byte[] file, string contentType)
    {
        var imageType = _mimeTypes.SingleOrDefault(x => x.Key.Equals(contentType));

        return file.Take(imageType.Value.Length).SequenceEqual(imageType.Value);
    }
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.