c# - net - openfiledialog.filter imagenes

Buena manera de comprobar si la extensión del archivo es de una imagen o no

Question

Tengo este tipo de archivos Filtros:

    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: ¿Hay filtros predeterminados en .NET o una biblioteca gratuita para eso?

Necesito un método estático que compruebe si una cadena es una imagen o no. Como resolverias esto?

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

Solución utilizando Jeroen Vannevel EndsWith. Creo que está bien.

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

Answer 1

Este método crea automáticamente un filtro para el OpenFileDialog . Utiliza la información de los decodificadores de imagen compatibles con Windows. También agrega información de formatos de imagen "desconocidos" (ver default caso default de la declaración de 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();
}

Úsalo así:

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

El código anterior (ligeramente modificado) se puede usar para encontrar las extensiones de archivo de imagen disponibles. Para probar si una extensión de archivo dada denota una imagen, pondría la extensión válida en un HashSet . HashSets tiene un
O (1) tiempo de acceso! Asegúrese de elegir un comparador de cadenas que no distinga mayúsculas y minúsculas. Como las extensiones de archivo no contienen letras acentuadas o no latinas, se puede ignorar la cultura de forma segura. Por lo tanto uso una comparación de cadenas ordinales.

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

Y prueba si un nombre de archivo es una imagen:

string extension = Path.GetExtension(filename);
bool isImage = imageExtensions.Contains(extension);

Answer 2

Podrías usar .endsWith(ext) . Sin embargo, no es un método muy seguro: podría cambiar el nombre de ''bla.jpg'' a ''bla.png'' y aún sería un archivo jpg.

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

This proporciona una solución más segura:

string InputSource = "mypic.png";
System.Drawing.Image imgInput = System.Drawing.Image.FromFile(InputSource);
Graphics gInput = Graphics.fromimage(imgInput);
Imaging.ImageFormat thisFormat = imgInput.rawformat;

Answer 3

Una opción sería tener una lista de todas las posibles extensiones de imagen válidas, entonces ese método solo verificará si la extensión provista está dentro de esa colección:

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

Luego, en la validación simplemente verificas eso:

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

Answer 4

private static readonly string[] _validExtensions = {"jpg","bmp","gif","png"}; //  etc

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

Si desea poder configurar la lista en tiempo de ejecución sin volver a compilar, agregue algo como:

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