MIME-Typ aus Dateinamenerweiterung ermitteln

Question

Wie kann ich den MIME-Typ aus einer Dateierweiterung ermitteln?

Answer 1

Sie sollten der Dateierweiterung, die vom Client kommt, nicht vertrauen. Überprüfen Sie immer die magische Zahl der Datei.

Verwendung von FileTpeInterrogator mit ASP.NET Core:

public static class FileTypeChecker
{
    private static List<string> validVideoMimeTypes = new List<string> { "video/mp4", "video/quicktime" };
    private static List<string> validImageMimeTypes = new List<string> { "image/png", "image/jpeg" };

    public static bool IsValidVideo(IFormFile file)
    {
        return validVideoMimeTypes.Contains(GetFileMimeType(file));
    }

    public static bool IsValidImage(IFormFile file)
    {
        return validImageMimeTypes.Contains(GetFileMimeType(file));
    }

    private static string GetFileMimeType(IFormFile file)
    {
        // You should have checked for null and file length before reaching here

        IFileTypeInterrogator interrogator = new FileTypeInterrogator.FileTypeInterrogator();

        byte[] fileBytes;
        using (var stream = new MemoryStream())
        {
            file.CopyTo(stream);
            fileBytes = stream.ToArray();
        }

        FileTypeInfo fileTypeInfo = interrogator.DetectType(fileBytes);
        return fileTypeInfo.MimeType.ToLower();
    }
}

Innerhalb Ihres Controllers oder Dienstes:

public IActionResult UploadVideo([FromForm] UploadVideoVM model)
{
    if (model.File.Length < minimumLength || model.File.Length > maximumLength)
    {
        // BadRequest => Size
    }
    else if (!FileTypeChecker.IsValidVideo(model.File))
    {
        // BadRequest => Type
    }
    else
    {
        // All good
    }

    return Ok();
}

Um den MIME-Typ einer Dateierweiterung zu erhalten, siehe diese Datei .

Answer 2

** MediaTypeNames Klasse verwenden-->Beispiel : MediaTypeNames.Application.Pdf **

Answer 3

Angeregt durch Samuels Antwort habe ich eine verbesserte Version geschrieben:

• Funktioniert auch, wenn die Erweiterung in Großbuchstaben geschrieben ist.
• Nimmt den Dateinamen als Eingabe, behandelt Dateien ohne Erweiterungen anständig.
• Fügen Sie keine "." in Schlüssel ein.
• Liste von Apache , für die ich einen kleines Transformationsskript .

Der resultierende Quellcode ist über 30K Zeichen lang, so dass ich ihn hier nicht posten kann, schauen Sie ihn sich an auf Github .

Answer 4

Diese Hilfsklasse liefert Mime-Typ (Inhaltstyp), Beschreibung und Symbole für jeden Dateinamen:

using Microsoft.Win32;
using System;
using System.Drawing;
using System.IO;
using System.Runtime.InteropServices;

public static class Helper
{
    [DllImport("shell32.dll", CharSet = CharSet.Auto)]
    private static extern int ExtractIconEx(string lpszFile, int nIconIndex, IntPtr[] phIconLarge, IntPtr[] phIconSmall, int nIcons);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern int DestroyIcon(IntPtr hIcon);

    public static string GetFileContentType(string fileName)
    {
        if (fileName == null)
        {
            throw new ArgumentNullException("fileName");
        }

        RegistryKey registryKey = null;
        try
        {
            FileInfo fileInfo = new FileInfo(fileName);

            if (string.IsNullOrEmpty(fileInfo.Extension))
            {
                return string.Empty;
            }

            string extension = fileInfo.Extension.ToLowerInvariant();

            registryKey = Registry.ClassesRoot.OpenSubKey(extension);
            if (registryKey == null)
            {
                return string.Empty;
            }

            object contentTypeObject = registryKey.GetValue("Content Type");
            if (!(contentTypeObject is string))
            {
                return string.Empty;
            }

            string contentType = (string)contentTypeObject;

            return contentType;
        }
        catch (Exception)
        {
            return null;
        }
        finally
        {
            if (registryKey != null)
            {
                registryKey.Close();
            }
        }
    }

    public static string GetFileDescription(string fileName)
    {
        if (fileName == null)
        {
            throw new ArgumentNullException("fileName");
        }

        RegistryKey registryKey1 = null;
        RegistryKey registryKey2 = null;
        try
        {
            FileInfo fileInfo = new FileInfo(fileName);

            if (string.IsNullOrEmpty(fileInfo.Extension))
            {
                return string.Empty;
            }

            string extension = fileInfo.Extension.ToLowerInvariant();

            registryKey1 = Registry.ClassesRoot.OpenSubKey(extension);
            if (registryKey1 == null)
            {
                return string.Empty;
            }

            object extensionDefaultObject = registryKey1.GetValue(null);
            if (!(extensionDefaultObject is string))
            {
                return string.Empty;
            }

            string extensionDefaultValue = (string)extensionDefaultObject;

            registryKey2 = Registry.ClassesRoot.OpenSubKey(extensionDefaultValue);
            if (registryKey2 == null)
            {
                return string.Empty;
            }

            object fileDescriptionObject = registryKey2.GetValue(null);
            if (!(fileDescriptionObject is string))
            {
                return string.Empty;
            }

            string fileDescription = (string)fileDescriptionObject;
            return fileDescription;
        }
        catch (Exception)
        {
            return null;
        }
        finally
        {
            if (registryKey2 != null)
            {
                registryKey2.Close();
            }

            if (registryKey1 != null)
            {
                registryKey1.Close();
            }
        }
    }

    public static void GetFileIcons(string fileName, out Icon smallIcon, out Icon largeIcon)
    {
        if (fileName == null)
        {
            throw new ArgumentNullException("fileName");
        }

        smallIcon = null;
        largeIcon = null;

        RegistryKey registryKey1 = null;
        RegistryKey registryKey2 = null;
        try
        {
            FileInfo fileInfo = new FileInfo(fileName);

            if (string.IsNullOrEmpty(fileInfo.Extension))
            {
                return;
            }

            string extension = fileInfo.Extension.ToLowerInvariant();

            registryKey1 = Registry.ClassesRoot.OpenSubKey(extension);
            if (registryKey1 == null)
            {
                return;
            }

            object extensionDefaultObject = registryKey1.GetValue(null);
            if (!(extensionDefaultObject is string))
            {
                return;
            }

            string defaultIconKeyName = string.Format("{0}\\DefaultIcon", extensionDefaultObject);

            registryKey2 = Registry.ClassesRoot.OpenSubKey(defaultIconKeyName);
            if (registryKey2 == null)
            {
                return;
            }

            object defaultIconPathObject = registryKey2.GetValue(null);
            if (!(defaultIconPathObject is string))
            {
                return;
            }

            string defaultIconPath = (string)defaultIconPathObject;
            if (string.IsNullOrWhiteSpace(defaultIconPath))
            {
                return;
            }

            string iconfileName = null;
            int iconIndex = 0;

            int commaIndex = defaultIconPath.IndexOf(",");
            if (commaIndex > 0)
            {
                iconfileName = defaultIconPath.Substring(0, commaIndex);
                string iconIndexString = defaultIconPath.Substring(commaIndex + 1);

                if (!int.TryParse(iconIndexString, out iconIndex))
                {
                    iconIndex = 0;
                }
            }
            else
            {
                iconfileName = defaultIconPath;
                iconIndex = 0;
            }

            IntPtr[] phiconSmall = new IntPtr[1] { IntPtr.Zero };
            IntPtr[] phiconLarge = new IntPtr[1] { IntPtr.Zero };

            int readIconCount = ExtractIconEx(iconfileName, iconIndex, phiconLarge, phiconSmall, 1);

            if (readIconCount < 0)
            {
                return;
            }

            if (phiconSmall[0] != IntPtr.Zero)
            {
                smallIcon = (Icon)Icon.FromHandle(phiconSmall[0]).Clone();
                DestroyIcon(phiconSmall[0]);
            }

            if (phiconLarge[0] != IntPtr.Zero)
            {
                largeIcon = (Icon)Icon.FromHandle(phiconLarge[0]).Clone();
                DestroyIcon(phiconLarge[0]);
            }

            return;
        }
        finally
        {
            if (registryKey2 != null)
            {
                registryKey2.Close();
            }

            if (registryKey1 != null)
            {
                registryKey1.Close();
            }
        }
    }
}

---

Verwendung :

string fileName = "NotExists.txt";
string contentType = Helper.GetFileContentType(fileName); // "text/plain"
string description = Helper.GetFileDescription(fileName); // "Text Document"
Icon smallIcon, largeIcon;
Helper.GetFileIcons(fileName, out smallIcon, out largeIcon); // 16x16, 32x32 icons

Answer 5

Sie können die Tabelle verwenden, die von Apache 's httpd. Es sollte trivial sein, dies in eine Funktion, ein Wörterbuch, eine Liste usw. zu übertragen.

Außerdem, wie gesehen ici , extension->mime type ist nicht unbedingt eine Funktion. Es kann mehrere gängige MIME-Typen pro Dateierweiterung geben, daher sollten Sie sich die Anforderungen Ihrer Anwendung ansehen und herausfinden, warum Sie sich für MIME-Typen interessieren, was Sie mit ihnen "machen" wollen usw. Können Sie Dateierweiterungen verwenden, um das gleiche Verhalten zu erreichen? Müssen Sie auch die ersten paar Bytes einer Datei lesen, um den MIME-Typ zu bestimmen?