buon modo per verificare se l'estensione del file è di un'immagine o no

Question

ho questo tipi di file Filtri:

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: C'è qualche filtri predefiniti in .NET o una libreria libera per questo?

Ho bisogno di un metodo statico che controlli se una stringa è un'immagine o meno. Come risolverebbe questo?

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

Soluzione con Jeroen Vannevel EndsWith. Penso che sia ok.

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

Answer 1

È possibile utilizzare .endsWith(ext). Tuttavia, non è un metodo molto sicuro: potrei rinominare "bla.jpg" in "bla.png" e sarebbe comunque un file jpg.

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

This fornisce una soluzione più sicura:

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

Answer 2

Un'opzione sarebbe quella di avere un elenco di tutte le possibili estensioni di immagini valide, allora quel metodo sarebbe solo verificare se la prolunga in dotazione è all'interno di tale raccolta :

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

Poi nella convalida basta controllare che contro:

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

Answer 3

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

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

Se si vuole essere in grado di fare l'elenco configurabile in fase di esecuzione senza ricompilare, aggiungere qualcosa come:

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

Answer 4

questo metodo crea automaticamente un filtro per la OpenFileDialog. Utilizza le informazioni dei decodificatori di immagine supportati da Windows. Aggiunge inoltre informazioni su formati di immagine "sconosciuti" (vedere il caso default dell'istruzione 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(); 
} 

usare in questo modo:

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

---

Il codice di cui sopra (leggermente modificato) può essere utilizzato per trovare le estensioni dei file immagine disponibili. Per verificare se una determinata estensione di file denota un'immagine, inserisco l'estensione valida in HashSet. Gli hash hanno un tempo di accesso O (1)! Assicurati di scegliere un comparatore di stringhe senza distinzione tra maiuscole e minuscole. Poiché le estensioni di file non contengono lettere accentate o non latine, la cultura può essere tranquillamente ignorata. Pertanto io uso un confronto di stringhe ordinali.

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

e verificare se il nome del file è l'immagine:

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