web-dev-qa-db-fra.com

Bon moyen de vérifier si l'extension de fichier est d'une image ou non

J'ai ces types de fichiers Filtres:

    public const string Png = "PNG Portable Network Graphics (*.png)|" + "*.png";
    public const string Jpg = "JPEG File Interchange Format (*.jpg *.jpeg *jfif)|" + "*.jpg;*.jpeg;*.jfif";
    public const string Bmp = "BMP Windows Bitmap (*.bmp)|" + "*.bmp";
    public const string Tif = "TIF Tagged Imaged File Format (*.tif *.tiff)|" + "*.tif;*.tiff";
    public const string Gif = "GIF Graphics Interchange Format (*.gif)|" + "*.gif";
    public const string AllImages = "Image file|" + "*.png; *.jpg; *.jpeg; *.jfif; *.bmp;*.tif; *.tiff; *.gif";
    public const string AllFiles = "All files (*.*)" + "|*.*";

    static FilesFilters()
    {
        imagesTypes = new List<string>();
        imagesTypes.Add(Png);
        imagesTypes.Add(Jpg);
        imagesTypes.Add(Bmp);
        imagesTypes.Add(Tif);
        imagesTypes.Add(Gif);
   }

OBS: Existe-t-il des filtres par défaut dans .NET ou une bibliothèque gratuite pour cela?

J'ai besoin d'une méthode statique qui vérifie si une chaîne est une image ou non. Comment résoudriez-vous cela?

    //ext == Path.GetExtension(yourpath)
    public static bool IsImageExtension(string ext)
    {
        return (ext == ".bmp" || .... etc etc...)
    }

Solution utilisant Jeroen Vannevel EndsWith. Je pense que c'est ok.

    public static bool IsImageExtension(string ext)
    {
        return imagesTypes.Contains(ext);
    }
c#file-extensionopenfiledialogfilefilter
20
Pedro77

Vous pouvez utiliser .endsWith(ext). Ce n'est pas une méthode très sécurisée cependant: je pourrais renommer 'bla.jpg' en 'bla.png' et ce serait toujours un fichier jpg.

public static bool HasImageExtension(this string source){
 return (source.EndsWith(".png") || source.EndsWith(".jpg"));
}

This fournit une solution plus sécurisée:

string InputSource = "mypic.png";
System.Drawing.Image imgInput = System.Drawing.Image.FromFile(InputSource);
Graphics gInput = Graphics.fromimage(imgInput);
Imaging.ImageFormat thisFormat = imgInput.rawformat;
15
Jeroen Vannevel
private static readonly string[] _validExtensions = {"jpg","bmp","gif","png"}; //  etc

public static bool IsImageExtension(string ext)
{
    return _validExtensions.Contains(ext.ToLower());
}

Si vous voulez pouvoir rendre la liste configurable au moment de l'exécution sans recompiler, ajoutez quelque chose comme:

private static string[] _validExtensions;

private static string[] ValidExtensions()
{
    if(_validExtensions==null)
    { 
        // load from app.config, text file, DB, wherever
    }
    return _validExtensions
}

public static bool IsImageExtension(string ext)
{
    return ValidExtensions().Contains(ext.ToLower());
}
15
nathanchere

Cette méthode crée automatiquement un filtre pour le OpenFileDialog. Il utilise les informations des décodeurs d'images pris en charge par Windows. Il ajoute également des informations sur les formats d'image "inconnus" (voir default cas de l'instruction switch).

private static string SupportedImageDecodersFilter()
{
    ImageCodecInfo[] encoders = ImageCodecInfo.GetImageEncoders();

    string allExtensions = encoders
        .Select(enc => enc.FilenameExtension)
        .Aggregate((current, next) => current + ";" + next)
        .ToLowerInvariant();
    var sb = new StringBuilder(500)
        .AppendFormat("Image files  ({0})|{1}", allExtensions.Replace(";", ", "),
                      allExtensions);
    foreach (ImageCodecInfo encoder in encoders) {
        string ext = encoder.FilenameExtension.ToLowerInvariant();
        // ext = "*.bmp;*.dib;*.rle"           descr = BMP
        // ext = "*.jpg;*.jpeg;*.jpe;*.jfif"   descr = JPEG
        // ext = "*.gif"                       descr = GIF
        // ext = "*.tif;*.tiff"                descr = TIFF
        // ext = "*.png"                       descr = PNG

        string caption;
        switch (encoder.FormatDescription) {
            case "BMP":
                caption = "Windows Bitmap";
                break;
            case "JPEG":
                caption = "JPEG file";
                break;
            case "GIF":
                caption = "Graphics Interchange Format";
                break;
            case "TIFF":
                caption = "Tagged Image File Format";
                break;
            case "PNG":
                caption = "Portable Network Graphics";
                break;
            default:
                caption = encoder.FormatDescription;
                break;
        }
        sb.AppendFormat("|{0}  ({1})|{2}", caption, ext.Replace(";", ", "), ext);
    }
    return sb.ToString();
}

Utilisez-le comme ceci:

var dlg = new OpenFileDialog {
    Filter = SupportedImageDecodersFilter(),
    Multiselect = false,
    Title = "Choose Image"
};

Le code ci-dessus (légèrement modifié) peut être utilisé pour trouver les extensions de fichier image disponibles. Afin de tester si une extension de fichier donnée dénote une image, je mettrais l'extension valide dans un HashSet. Les HashSets ont un
O (1) temps d'accès! Assurez-vous de choisir un comparateur de chaînes insensible à la casse. Étant donné que les extensions de fichier ne contiennent pas de lettres accentuées ou non latines, la culture peut être ignorée en toute sécurité. Par conséquent, j'utilise une comparaison de chaînes ordinales.

var imageExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
imageExtensions.Add(".png");
imageExtensions.Add(".bmp");
...

Et testez si un nom de fichier est une image:

string extension = Path.GetExtension(filename);
bool isImage = imageExtensions.Contains(extension);
5
Olivier Jacot-Descombes

Une option serait d'avoir une liste de toutes les extensions d'image valides possibles, alors cette méthode ne vérifierait que si l'extension fournie se trouve dans cette collection:

private static readonly HashSet<string> validExtensions = new HashSet<string>()
{
    "png",
    "jpg",
    "bmp"
    // Other possible extensions
};

Ensuite, dans la validation, il vous suffit de vérifier cela:

public static bool IsImageExtension(string ext)
{
    return validExtensions.Contains(ext);
}
4
Alejandro

Je devais juste faire quelque chose de similaire. Voici ma solution:

    private bool isImage(string fileExtension)
    {
        if (getImageFileExtensions().Contains(fileExtension.ToLower()))
            return true;
        else
            return false;
    }

    private static List<string> getImageFileExtensions()
    {
        var imageFileExtensions = ImageCodecInfo.GetImageEncoders()
                                  .Select(c => c.FilenameExtension)
                                  .SelectMany(e => e.Split(';'))
                                  .Select(e => e.Replace("*", "").ToLower())
                                  .ToList();
        return imageFileExtensions;
    }
1
Blechdose