.NET ব্যবহার করে, আপনি কীভাবে ফাইলের স্বাক্ষরের উপর ভিত্তি করে কোনও ফাইলের মাইম টাইপটি খুঁজে পাবেন না এক্সটেনশন


241

আমি একটি মাইম টাইপ পাওয়ার জন্য একটি সহজ উপায় সন্ধান করছি যেখানে ফাইল এক্সটেনশনটি ভুল বা দেওয়া হয়নি, কেবলমাত্র নেট। নেট-এ এই প্রশ্নের অনুরূপ ।


এটি এই প্রশ্নের অনুরূপ মনে হচ্ছে ।
গ্রেগ হিউগিল

22
আমি আশা করি যখন প্রয়োজনীয়তাটি পরিষ্কারভাবে বলা হয় যে আমি এক্সটেনশানটি ব্যবহার করবেন না তখনই আমি ফাইল "এক্সটেনশন" ব্যবহার করে সমস্ত "জাল উত্তরগুলি" সরিয়ে ফেলতে পারি!
এডওয়ার্ড ওলামিসান

1
এটি একটি পুরানো প্রশ্ন হতে পারে, তবে সমস্যাটি এখনও রয়ে গেছে। আমি এখানে প্রতিটি উত্তরকে তাদের ভিত্তিতে কেবল উইন্ডোজ এক্সিকিউটেবলগুলি পরীক্ষা করে দেখি; লিনাক্স বা আইওএস এক্সিকিউটেবল বা বিপজ্জনক ফাইলগুলি সম্পর্কে কী বলা যায়?
ফিলিপএইচ

@ ফিলিপএইচ তাদের জন্য একটি উত্তর লিখুন।
ওয়াজ

উত্তর:


83

Urlmon.dll এ, একটি ফাংশন বলা হয় FindMimeFromData

ডকুমেন্টেশন থেকে

মাইম টাইপ সনাক্তকরণ, বা "ডেটা স্নিফিং" বাইনারি ডেটা থেকে উপযুক্ত এমআইএমআই টাইপ নির্ধারণের প্রক্রিয়াটিকে বোঝায়। চূড়ান্ত ফলাফলটি সার্ভার সরবরাহিত MIME টাইপ শিরোনাম, ফাইল এক্সটেনশান এবং / অথবা ডেটা নিজেই সংমিশ্রণের উপর নির্ভর করে। সাধারণত, কেবলমাত্র প্রথম 256 বাইট ডেটা তাৎপর্যপূর্ণ।

সুতরাং, ফাইলটি থেকে প্রথম (অবধি) 256 বাইট পড়ুন এবং এতে পাস করুন FindMimeFromData


6
এই পদ্ধতিটি কতটা নির্ভরযোগ্য?
জন বুব্রিস্কি

22
স্ট্যাকওভারফ্লো / প্রশ্নগুলি / 4833113/… অনুসারে , এই ফাংশনটি কেবল 26 প্রকার নির্ধারণ করতে সক্ষম, তাই আমি এটি নির্ভরযোগ্য বলে মনে করি না। যেমন '* .ডোক্স' ফাইলটি 'অ্যাপ্লিকেশন / এক্স-জিপ-সংকুচিত' হিসাবে নির্ধারিত হয়।
মনসাইনর

54
আমি মনে করি এটি কারণ ডকএক্স অবশ্যই একটি জিপ ফাইল।
নিক দেভেরাক্স

27
DOCX হয় একটি ZIP ফাইল কিন্তু .docx জন্য MimeType "অ্যাপ্লিকেশন / vnd.openxmlformats-officedocument.wordprocessingml.document" হয়। যদিও এই বাইনারি-একমাত্র পরীক্ষা থেকে নির্ধারিত হতে পারে, এটি সম্ভবত এটি করার সবচেয়ে কার্যকর উপায় নয় এবং বেশিরভাগ ক্ষেত্রে আপনাকে প্রথম 256 বাইটের বেশি পড়তে হবে।
BrainSlugs83

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
সম্ভবত যা কিছু রেজিস্ট্রি ম্যাপ করা হয়।
mkmurray


6
যখন বিষয়টি উইন্ডোজ 8 আইআইএস এটা হোস্টিং pinvoke.net উপর বাস্তবায়ন (যা সূক্ষ্ম পার্থক্য আছে) ব্যবহার মীমাংসিত আমি এই কোড সহ একটি সমস্যাতে পড়েছি pinvoke.net/default.aspx/urlmon.findmimefromdata
Rohland

2
আমি এই কোডটি আইআইএস 7 দিয়ে পরীক্ষা করে যাচ্ছি এবং এটি আমার পক্ষে কাজ করে না। আমার একটি সিএসভি ফাইল রয়েছে যা আমি পরীক্ষা করছি। আমি সিএসভির এক্সটেনশন (.png, .jpeg, ইত্যাদি) এবং এক্সটেনশন (চিত্র / পিএনজি, চিত্র / জেপেইগ) এর সাথে মাইমটাইপের পরিবর্তনগুলি পরিবর্তন করছি। আমি ভুল হতে পারি, তবে এটি আমার বোঝা ছিল যে উর্মোন.ডিল ফাইলের মেটাডেটা ব্যবহার করে মাইমেটাইপ নির্ধারণ করেছে, এটি কেবল এটির সম্প্রসারণ নয়
কনারবোড

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
এটি তবে ফাইলের নামের উপর ভিত্তি করে। এটি কেবল ওপি নয়, কারও পক্ষে উপকারী হতে পারে যারা ফাইলের সামগ্রী দ্বারা এটি করতে চেয়েছিলেন wanted
মান্দেরেকো

4
এই তালিকার একটি উপসেট ওয়েব ম্যাসেজের জন্যও উপযুক্ত। ধন্যবাদ!
ডেরিক

8
আপনার লক্ষের উপর নির্ভর করে আপনি "অজানা / অজানা" পরিবর্তে "অ্যাপ্লিকেশন / অক্টেট স্ট্রিম" ফিরে আসতে চাইতে পারেন।
নিকোলাস রাউল

4
যেহেতু আমার সম্পাদনা প্রত্যাখ্যান করা হয়েছিল আমি এখানে পোস্ট করব: এক্সটেনশনটি অবশ্যই সমস্ত নিম্নতর ক্ষেত্রে হতে পারে, না এটি অভিধানে পাওয়া যাবে না।
হাওয়ে

3
@ জালালআল্ডিনসাহ'ড - StringComparer.OrdinalIgnoreCaseঅভিধান নির্মাণকারীর পক্ষে আরও একটি ভাল ফিক্স আইএমএইচও হবে । সাধারণ তুলনা হতাশার চেয়ে দ্রুত এবং আপনি এর থেকে এবং তারতম্যগুলি থেকে মুক্তি পাবেন .ToLower()
Ivaylo স্লাভভ

87

সম্পাদনা: শুধু ব্যবহার করুন মাইম ডিটেক্টিভ

আমি প্রদত্ত ফাইলের সঠিক এমআইএমআই টাইপ নির্ধারণ করতে বাইট অ্যারে ক্রমগুলি ব্যবহার করি। ফাইলের নামের ফাইল এক্সটেনশনের দিকে তাকানোর সুবিধাটি হ'ল কোনও ব্যবহারকারী যদি নির্দিষ্ট ফাইল টাইপ আপলোড বিধিনিষেধগুলিকে বাইপাস করার জন্য কোনও ফাইলের নাম পরিবর্তন করে রাখে তবে ফাইলের নাম এক্সটেনশন এটি ধরতে ব্যর্থ হবে। অন্যদিকে, বাইট অ্যারের মাধ্যমে ফাইলের স্বাক্ষর পাওয়ার ফলে এই দুষ্টু আচরণটি হওয়া বন্ধ হবে।

এখানে সি # তে একটি উদাহরণ রয়েছে:

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


}

লক্ষ্য করুন যে আমি ডসএক্সএক্স ফাইলের ধরণগুলি আলাদাভাবে পরিচালনা করেছি কারণ ডোকসএক্স সত্যই কেবল একটি জিপ ফাইল। এই দৃশ্যে আমি একবার ফাইল এক্সটেনশনটি যাচাই করে নিই যে এটির ক্রমটি রয়েছে। এই উদাহরণটি কিছু লোকের পক্ষে সম্পূর্ণ দূরে, তবে আপনি সহজেই নিজের যুক্ত করতে পারেন।

আপনি যদি আরও মাইম টাইম যুক্ত করতে চান তবে আপনি এখান থেকে অনেকগুলি বিভিন্ন ধরণের ফাইলের বাইট অ্যারে ক্রমগুলি পেতে পারেন । এছাড়াও, এখানে আরও একটি ভাল সংস্থান রয়েছে ফাইল স্বাক্ষর সম্পর্কিত ।

আমি সমস্ত সময় যা করতে পারি তা যদি ব্যর্থ হয় তবে নির্দিষ্ট ধরণের কয়েকটি ফাইল যা আমি সন্ধান করছি এবং ফাইলগুলির বাইট অনুক্রমের জন্য একটি প্যাটার্ন খুঁজছি। শেষ পর্যন্ত, এটি এখনও মূল যাচাইকরণ এবং ফাইলের ধরণ নির্ধারণের 100% প্রমাণের জন্য ব্যবহার করা যাবে না।


1
ধন্যবাদ @ আরএফএলডব্লিউটাইম - যখন আমাদের কাছে বাইট অ্যারে রয়েছে তবে ফাইলনাম / এক্সটেনশন নেই তখন আমি এটি হ্যান্ডেল করতে কিছুটা বাড়িয়েছি। (অবশ্যই কিছু মাইম প্রকারের জন্য এটি ডিফল্ট হওয়া দরকার, বা সঠিকভাবে সনাক্ত করতে আরও বাড়ানো দরকার)। তবে কেউ যদি আমাকে কোড পোস্ট করতে চান তবে আমাকে জানান let
ক্রিস

বাইট ব্যবহারের জন্য +1। এটি পরীক্ষা করার জন্য এখন কোনও নির্দিষ্ট মাইম-টাইপের জন্য প্রত্যাশিত সংখ্যক বাইটও নিতে পারে (256 এর ডিফল্ট নয়)। তবে, আমি এখানে একটি কাঠামোতে যাব, এক্সটেনশন, বাইট এবং মাইম / টাইপ হিসাবে বৈশিষ্ট্য হিসাবে এবং সম্ভবত প্রাক-সংজ্ঞায়িত স্ট্রাক্টের একটি অভিধান রাখি। এটি আমার যদি অবিরাম চেকগুলি অবিরাম রক্ষা করতে পারে
Ivaylo Slavov

2
এই পদ্ধতির সমস্যাটি হ'ল উদাহরণস্বরূপ, "এমজেড" দিয়ে শুরু হওয়া একটি টেক্সট ফাইলটি .EXE ফাইল হিসাবে ব্যাখ্যা করা হবে। অন্য কথায়, আপনার মিথ্যা ধনাত্মকতা এড়াতে কমপক্ষে সমস্ত ক্ষেত্রে এক্সটেনশনের পাশাপাশি আরও দীর্ঘতর স্বাক্ষর বা প্রতি-ফর্ম্যাট হিউরিস্টিক বিবেচনা করা উচিত।
নস্টর সানচেজ এ।

1
@ সংক্ষিপ্তরূপে আমি বিশ্বাস করি যে এক্সএলএসের শেষে একটি 0 বাইট রয়েছে যেখানে ডওসি নেই, তাই প্রথমে এক্সএলএস পরীক্ষা করুন, তারপরে ডওসি। এক্সএলএসএক্স / ডোকএক্স হিসাবে, তারা একই স্বাক্ষর (জিপ) ভাগ করে, তাই তাদের আলাদা করার জন্য আপনার হেডার পড়ার চেয়ে আরও গভীরতর প্রয়োজন to উদাহরণস্বরূপ, এক্সএলএসএক্স ফাইলগুলির শিরোনামের নিকটে "xl / _rels / workbook.xML.rels" স্ট্রিং রয়েছে তবে DOCX ফাইলগুলিতে শিরোনামের কাছে "শব্দ / _আরেলস / ডকুমেন্ট.এক্সএমএল.রেলস" স্ট্রিং রয়েছে। এই নির্দিষ্ট ধরণের ধরণের চেষ্টা এবং পার্থক্য করার এটি কেবলমাত্র এক উপায় এবং এটি অবশ্যই 100% পরিস্থিতিতে আবরণ করে না। (উদা।
ডপএক্সএক্স

7
এই যে বন্ধুরা. আমি কীভাবে গিথুবে মাইমডেটিভটিভের কাছে মূল ফাইলটাইপ-ডিটেকটিভকে কাঁটাযুক্ত করেছি। আমি যদি খুশী তবে এটি কার্যকর। এবং আমি বিকাশকারী ট্রেলম্যাক্সের সাথে কথা বলেছি। আমরা এমআইটিতে লাইসেন্স পরিবর্তন করেছি!
মুরাদ নোফাল

36

আপনি যদি নেট ফ্রেমওয়ার্ক 4.5 বা তার বেশি ব্যবহার করছেন তবে এখন একটি মাইম্যাপিং GGetMimeMapping (ফাইলের নাম) পদ্ধতি রয়েছে যা পাস ফাইল ফাইলটির জন্য সঠিক মাইম ম্যাপিংয়ের সাথে একটি স্ট্রিং ফিরিয়ে দেবে। নোট করুন যে এটি ফাইলের ডেটা নয়, ফাইল এক্সটেনশন ব্যবহার করে।

ডকুমেন্টেশনটি http://msdn.microsoft.com/en-us/library/system.web.mimemapping.getmimemapping এ রয়েছে


3
এটি আমার পক্ষে কাজ করেছে এবং এটি কেবল কোডের একটি লাইন নিয়েছে। var mimetype = System.Web.MimeMapping.GetMimeMapping(<pathToFile>);
গ্যারি

50
এটি "যদি ফাইল এক্সটেনশানটি ভুল বা অনুপস্থিত থাকে" তবে মূল প্রশ্নের উত্তর দেয় না। গেটমাইম্যাপিং কেবল এক্সটেনশন এবং মাইম এন্ট্রিগুলির একটি স্থির অভিধান ব্যবহার করে।
ব্যারি হাগান

1
আমি এই ক্লাসটি খুব
ব্যবহারযোগ্য

1
। নেট-কোর পাওয়া যায় না। পরিবর্তে আপনি ব্যবহার করতে পারেন: স্ট্রিং কন্টেন্টটাইপ; নতুন ফাইলএক্সটেনশন কনটেন্টটাইপপ্রোভাইডার ()। ট্রাইগেট কনটেন্টটাইপ (ফাইলের নাম, কনটেন্টটাইপ আউট); কন্টেন্টটাইপ = কন্টেন্টটাইপ ?? "অ্যাপ্লিকেশন / অক্টেট-স্ট্রীম";
জন পানকোভিজ

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

আপনি মাইমসের একটি ডাটাবেসে ট্যাপ করতে যাচ্ছেন এমন এক উপায় বা অন্য কোনও উপায় - তারা এক্সটেনশানগুলি থেকে জাদুযুক্ত বা ম্যাজিক নম্বর কিছুটা তুচ্ছ - উইন্ডোজ রেজিস্ট্রি এমন একটি জায়গা। প্ল্যাটফর্মের স্বতন্ত্র সমাধানের জন্য যদিও কোড (বা স্ট্যান্ডেলোন লাইব্রেরি হিসাবে) সহ এই ডিবিটিকে পাঠাতে হবে।


1
@ রব্বি যদিও প্রশ্নটি বিষয়বস্তু ফাইল করার জন্য নির্দিষ্ট ছিল এবং প্রসার নয়, তবুও এই উত্তরটি এখনও অন্য লোকদের (যেমন আমার মতো) পাস হতে চলেছে তাদের পক্ষে কার্যকর হতে পারে। এমনকি যদি এর মতো কোনও উত্তর গৃহীত হওয়ার সম্ভাবনা নাও থাকে তবে তথ্যটি পাওয়া খুব ভাল।
BrainSlugs83

5
এটি কেবল ফাইল নামটির প্রসারের উপর ভিত্তি করে মাইম পায় না? ফাইলটি যদি একটি .ডোক্স এবং কিছু ক্লাউন তার নাম পরিবর্তন করে .ডাক করার সিদ্ধান্ত নিয়েছিল তবে কী হবে? আপনি অবশ্যই ভুল মাইম টাইপ পেয়েছেন।
কলিন

8
@ কোলিন, আপনি একেবারে সঠিক, তবে এই উক্তিটি "এটি একটি নির্বোধ প্রমাণ হিসাবে প্রমাণ করুন এবং কেউ কেবল আরও ভাল বোকামি তৈরি করবে।" :)
সের্গেই

উইন্ডোজ আজুর ওয়েব ভূমিকা বা অন্য কোনও হোস্টের সাথে কাজ করার সময় যা আপনার অ্যাপ্লিকেশনটি সীমাবদ্ধ ট্রাস্টে চালিত করে - ভুলে যাবেন না যে আপনাকে রেজিস্ট্রি অ্যাক্সেস করতে দেওয়া হবে না। রেজিস্ট্রি করার জন্য ক্যাচ-ক্যাচারের সংমিশ্রণ এবং মেমোরি অভিধানের মতো এনকির উত্তর যেমন দু'টি রয়েছে এমন একটি ভাল সমাধান বলে মনে হচ্ছে।
অগ্নিয়ান দিমিত্রভ

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

@ প্রণবশাহ, নোট করুন যে মাইম-প্রকারের সার্ভারগুলির জ্ঞান (যাঁরা রেজিস্ট্রি দেখিয়ে ফিরে আসেন) সার্ভারে কী সফ্টওয়্যার ইনস্টল করা হয়েছে তার সাথে সম্পর্কিত। একটি বেসিক উইন্ডোজ ইনস্টলেশন, বা ডেডিকেটেড ওয়েব সার্ভারটি মাইম-প্রকারের তৃতীয় পক্ষের সফ্টওয়্যারটি নির্ভরযোগ্য হওয়া উচিত নয় যা প্রয়োজনীয়ভাবে ইনস্টল করা নেই। তবুও, এটি .docফাইলটি কী তা জেনে রাখা উচিত ।
Ivaylo স্লাভভ

6

HeyRed.Mime.MimeGuesser.GuessMimeType আপনি যদি উইন্ডোজবিহীন পরিবেশে আপনার এএসপি.নেট সমাধানটি হোস্ট করতে চান তবে নুগেট থেকে চূড়ান্ত সমাধান হবে।

ফাইল এক্সটেনশান ম্যাপিং খুব নিরাপদ। যদি কোনও আক্রমণকারী অবৈধ এক্সটেনশানগুলি আপলোড করে, একটি ম্যাপিং অভিধানে উদাহরণস্বরূপ .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
এখনও অবধি, আমি চেষ্টা করেছি সেরা গ্রন্থাগার। আমি আমার ফোল্ডারে রেখে প্রতিটি ফাইলের জন্য সামগ্রীর ধরণের সন্ধান পেয়েছি। + নেট কোর সমর্থন!
টিএস

3

আমি মনে করি সঠিক উত্তরটি হ'ল স্টিভ মরগান এবং সেরোগির উত্তরগুলির সংমিশ্রণ। ইন্টারনেট এক্সপ্লোরার এটি এটি করে। পিনভোক কলটি FindMimeFromDataকেবল ২ hard টি হার্ড-কোডড মাইম ধরণের জন্য কাজ করে। এছাড়াও, এটি দ্ব্যর্থক মাইম প্রকারগুলি দেবে (যেমন text/plainবা হিসাবেapplication/octet-stream ) দেবে যদিও আরও নির্দিষ্ট, আরও উপযুক্ত মাইম প্রকারের উপস্থিতি থাকতে পারেযদি এটি একটি ভাল মাইম প্রকার দিতে ব্যর্থ হয় তবে আপনি আরও নির্দিষ্ট মাইম টাইপের জন্য রেজিস্ট্রিতে যেতে পারেন। সার্ভার রেজিস্ট্রিতে আরও আধুনিক যুগের মাইম প্রকার থাকতে পারে।

দেখুন: http://msdn.microsoft.com/en-us/library/ms775147(VS.85).aspx


3

এই শ্রেণিটি 3 টি বিভিন্ন উপায়ে চেষ্টা করতে পূর্ববর্তী উত্তরগুলি ব্যবহার করে: এক্সটেনশনের ভিত্তিতে হারকোড, ফাইন্ডমাইমফ্র্যামডেটা এপিআই এবং রেজিস্ট্রি ব্যবহার করে।

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/… - তবে কোথাও একটি ওয়েব পরিষেবা থাকা উচিত যা আপনি কেবল একটি ফাইলের নাম এবং কিছু বাইট প্রেরণ করতে পারেন এটিও একটি সেরা অনুমান করতে পারে এবং
বাকীগুলি

আমি এটির জন্য কনফিগারেশন ব্যবহার করব, তাই কোডের একক লাইন পরিবর্তন না করেই আমার প্রয়োজনীয় মাইম-প্রকারগুলি বেছে নিতে এবং সে অনুযায়ী তাদের সংশোধন করতে পারি
Ivaylo Slavov

2

আমি একই ইস্যুটি জুড়ে এসে শেষ পর্যন্ত আমার এখানে কিরক বাউকমের সমাধানটির নিজস্ব স্বাদ বেছে নিয়েছি

আমার কাছে মনে হয় এটি কারও জন্য একটি অনলাইন লুক-আপ পরিষেবা লেখার সুযোগ।

যাইহোক, আশা করি এটি সাহায্য করবে।


2

যদি কেউ এটির জন্য থাকে তবে তারা দুর্দান্ত পার্ল মডিউল ফাইল :: টাইপ করতে পারে নোট থেকে করতে পারে। কোডটিতে ফাইলের শিরোনামের ম্যাজিক নম্বরের প্রতিটি সেট টাইপ বা রেজেক্স মিলগুলির জন্য চেহারা রয়েছে of

এখানে একটি নেট নেট টাইপ সনাক্তকারী লাইব্রেরি http://filetypedetective.codeplex.com/ তবে এটি এই মুহুর্তে কেবলমাত্র একটি ছোট সংখ্যক ফাইল সনাক্ত করে।


2

এই উত্তরটি লেখকের উত্তরের (রিচার্ড গুরলে) একটি অনুলিপি, তবে আইআইএস 8 / উইন ২০১২ (যেখানে ফাংশনটি অ্যাপ পুলটি ক্রাশের কারণ হতে পারে) এর সমস্যাগুলি সমাধান করতে উন্নত হয়েছে, রোহল্যান্ডের মন্তব্যটির উপর ভিত্তি করে http://www.pinvoke.net /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);

চমৎকার সি + পি সক্ষম উত্তর। Chrs
মেমিডিপোপার

2

@ স্টিভ মরগান এবং @ রিচার্ড গুরলে এটি দুর্দান্ত সমাধান, এর জন্য আপনাকে ধন্যবাদ। একটি ছোট অপূর্ণতা হ'ল যখন কোনও ফাইলে বাইটের সংখ্যা 255 বা নীচে হয়, মাইম টাইপটি মাঝে মাঝে "অ্যাপ্লিকেশন / অক্টেট-স্ট্রিম" উপস্থাপন করবে যা ফাইলগুলির জন্য কিছুটা ভুল নয় যা "পাঠ্য / প্লেইন" পাওয়ার আশা করে। এই পরিস্থিতির জন্য অ্যাকাউন্টে আমি আপনার মূল পদ্ধতিটি আপডেট করেছি:

যদি ফাইলটিতে বাইটের সংখ্যা 255 এর থেকে কম বা সমান হয় এবং ছাড়িত মাইম প্রকারটি "অ্যাপ্লিকেশন / অক্টেট-স্ট্রিম" হয়, তবে একটি নতুন বাইট অ্যারে তৈরি করুন যা মূল ফাইলের বাইটগুলি পুনরাবৃত্তি করে মোট সংখ্যা পর্যন্ত এন-বার করে বাইটগুলির>> = 256 Then তারপরে সেই নতুন বাইট অ্যারেতে মাইম-টাইপটি পুনরায় পরীক্ষা করুন।

পরিবর্তিত পদ্ধতি:

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

এটি ছিল আমার সমস্যা, এবং আপনার ধারণাটি দুর্দান্ত ছিল, বাইটগুলি অনুলিপি করার জন্য। আমি এটি সি # তে প্রয়োগ করতে হয়েছিল, তবে ফাইলটির দৈর্ঘ্য এবং ফাইলটির প্রথম বাইট রয়েছে এমন বাফার ব্যবহার করে, আমি সমস্ত অনুপস্থিত বাইটগুলি পুনরাবৃত্তি করতে পেরে এবং ফাইলটি পুনরাবৃত্তি করতে অ্যারেতে বাইটগুলি অনুলিপি করতে সক্ষম হয়েছি (i সবেমাত্র ফাইলের দৈর্ঘ্য আইডেক্স থেকে বাইটটি অনুলিপি করেছেন)।
রিচার্ড ডিউর

1

আইআইএস 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

উইন্ডোজ আজুর ওয়েব ভূমিকা বা সীমিত ট্রাস্টে আপনার অ্যাপ্লিকেশন চালিত অন্য কোনও হোস্টের সাথে কাজ করার সময় ভুলে যাবেন না যে আপনাকে রেজিস্ট্রি বা নিয়ন্ত্রণহীন কোড অ্যাক্সেসের অনুমতি দেওয়া হবে না। হাইব্রিড পদ্ধতির - পরীক্ষার জন্য রেজিস্ট্রি এবং ইন-মেমরি অভিধানের সংমিশ্রণটি একটি ভাল সমাধানের মতো দেখায় যাতে কিছুটা থাকে।

আমি এই কোডটি এটি করতে ব্যবহার করি:

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 ব্যবহার করেন তখন আমি আপনার কোডটিতে কোনও ট্রাই-ক্যাচ ব্লক দেখি না। সুতরাং, ডিফল্টরূপে দেখে মনে হচ্ছে আপনি কেবল ফাইলের এক্সটেনশানটি যাচাই করেন, যদি আপনি নিশ্চিত না হন তবে ফাইলটির অভ্যন্তরে আসলে কী তা সত্যই সহায়ক নয়। এবং আমি এখনও পেতে পারি না, কি সীমিত ট্রাস্টের সাথে অ্যাজুরে গেটমাইমটাইপফর্মফায়ার ইনটার্নাল কাজ করে? যদি তা না হয়, তবে কেন এখনও কোডটিতে রয়েছে?
আলেকজান্ডার স্কোগোরভ

1
সীমাবদ্ধ কার্যকর প্রয়োগের ক্ষেত্রে, আপনি কেবলমাত্র তালিকাটি ব্যবহারের জন্য কোডটি সীমাবদ্ধ করতে পারেন। হ্যাঁ, এর চেয়ে আরও বেশি এক্সটেনশন রয়েছে তবে কেবলমাত্র বিকাশকারী অ্যাপ্লিকেশনটির প্রসঙ্গটি জানেন এবং তালিকায় আরও যুক্ত করতে পারেন। এবং একটি ট্র্যাচ-ক্যাচ হ'ল ভাল সংযোজন যা নিশ্চিত।
অগ্নিয়ান দিমিত্রভ

0

আমি নেটোম্যাটিক্স থেকে উইনিস্টা মাইমডিটেক্টর ব্যবহার করে শেষ করেছি। আপনি কোনও অ্যাকাউন্ট তৈরি করার পরে উত্সগুলি বিনামূল্যে ডাউনলোড করা যাবে: http://www.netomatix.com/Products/DocamentManagement/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);

এটি এখানে উত্তর দেওয়া অন্য প্রশ্নের একটি অংশ: আরলমন.এফএলএল-এর আরও ফাইন্ডমাইমফ্র্যামডেটা পদ্ধতির বিকল্প যার মধ্যে আরও মাইম টাইম রয়েছে আমার মতে এই সমস্যার সেরা সমাধান।


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"

এই পোস্টটির জন্য ধন্যবাদ পিটিআরটিস্ট্রিংউনি উইন্ডোজ 10 এ কাজ করে না এবং @ xanatos এ

আমি x64 এবং। নেট কোর 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.MimeDtetect প্রকল্পটি urlmon.dll এ ফ্যালব্যাক সহ । নেট কোর / কাঠামোয় রূপান্তর করেছি it এটি ব্যবহার করতে নিখরচায় পড়ুন : প্যাকেজ প্যাকেজ

   //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);
    }
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.