4 risposte

1. 5

   Una migliore può essere come questo,

    public bool CheckFileType(string FileName)
    {
       bool result = false ;
   
       try
        {
         string Ext = Path.GetExtension(FileName);
         switch (Ext.ToLower())
         {
           case ".gif":                   
           case ".JPEG":                    
           case ".jpg":                  
           case ".png":                   
           case ".bmp":                   
               result = true;
               break;
          }
   
         }catch(Exception e)
         {
            //Log exception 
         }
         return result;
        }

   -1 per abbandonare il Percorso chiamare fuori il try/catch.
   notato prima punta, comunque grazie per la pronta fuoco amico 😉
   il confronto “.JPEG” Ext.ToLower() è improbabile partita 😉
   Come usare il try/catch qui? OK basta metterli nel metodo corpo e basta. Mi piace questa risposta

   OriginaleL’autore Furqan Hameedi

2. 4

   Ci sono un sacco di modi che si possono utilizzare le eccezioni in metodi che restituiscono i valori:

   Luogo l’istruzione return fuori il try-catch Per esempio:

   T returnValue = default(T);
   try
   {
       //My code
   }
   catch 
   {
       //Exception handling code
   }
   return returnValue;

   Messo un ritorno economico all’interno del vostro cattura

   try
   {
       //My code
   }
   catch 
   {
       //Handle exception
       return default(T);
   }

   Lanciare un’eccezione

   Non hanno per restituire un valore, il metodo deve semplicemente fine (ad esempio, raggiungere un ritorno economico o di un’istruzione throw). A seconda eccezione per la sua non è sempre valido per restituire un valore.

   Si dovrebbe riflettere attentamente su quando e come intercettare e gestire le eccezioni:

   1. Quale potrebbe fallire?
   2. Perché /come possono fallire?
   3. Cosa devo fare quando vengono a mancare?

   Nel tuo caso:

   1. L’unica istruzione che può fallire è string Ext = Path.GetExtension(FileName);, che, secondo la documentazione può fallire se FileName contiene. (Nota che GetExtension non restituisce null, anche se FileName è null).
   2. Questo potrebbe accadere se l’utente ha fornito una stringa che contiene questi caratteri non validi.
   3. Se questo accade, credo che ci deve restituire false, per indicare che il percorso non è valido (ma questo dipende dall’applicazione).

   Così probabilmente sarei gestire le eccezioni, come questa:

   public bool CheckFileType(string FileName)
   {
       string Ext;
       try
       {
           Ext = Path.GetExtension(FileName);
       }
       catch (ArgumentException ex)
       {
           return false;
       }
       //Switch statement
   }

   Di notare che abbiamo solo intercettare l’eccezione che ci si aspetta (ArgumentException), e abbiamo solo posto il try dichiarazione circa l’affermazione che, ci aspettiamo che l’eccezione.

   In effetti è una buona idea per evitare di lancio e la cattura di eccezioni, dove possibile, non solo di subire una pena di prestazioni (che può causare seri problemi se questo metodo viene chiamato all’interno di un ciclo), ma si potrebbe inavvertitamente la cattura e la gestione di un’eccezione che non hai anticipare, di mascherare un problema più serio.

   In questo caso si può evitare di buttare l’eccezione interamente mediante il controllo di noi stessi per vedere se FileName contiene caratteri non validi:

   public bool CheckFileType(string FileName)
   {
       if (FileName == null)
       {
           return false;
       }
       if (FileName.IndexOfAny(System.IO.Path.GetInvalidPathChars()) >= 0)
       {
           return false;
       }
       //Your original method goes here
   }

   Non mi piace la cattura di ArgumentException. Io preferirei solo controllando il nome del file per i caratteri non validi con un se. Oltre a questo, grande risposta. +1.
   Credo che, in questo particolare caso, se si verifica un errore dovrebbe bolla dello stack, e non essere catturato\trattati in questo metodo.
   Eh, stavo solo aggiungere che hai postato 🙂
   Purtroppo (solo lettura): “L’array restituito da questo metodo non è garantito che contiene la serie completa di caratteri non validi per i nomi di file e directory.” 🙁
   Dipende dall’applicazione, in questo caso direi che il controllo di te stesso o di consentire l’eccezione è fine e cattura / coprente l’eccezione è meno favorevole, tuttavia l’ho mostrato, comunque, dato che in molti casi non si può evitare errori (come IO), e dimostra come pensare eccezioni (che potrebbe gettare? perché dovrebbe buttare? che cosa devo fare?)

   OriginaleL’autore Justin

3. 2

   Come non stai provando il tipo di file (solo l’estensione del nome), mi piacerebbe prima di iniziare rinominando il metodo. È possibile effettuare un metodo di estensione per gestire:

   public static bool HasImageExtension(this string fileName)
   {
       try
       {
           if (fileName == null) return false;
   
           string[] validExtensions = new string[] { ".gif", ".jpg", ".jpeg", ".png", ".bmp" };
   
           string extension = Path.GetExtension(fileName);
           return validExtensions.Contains(extension);
       }
       //catch the specific exception thrown if there are 
       //invalid characters in the path
       catch (ArgumentException ex) 
       {
           //do whatever you need to do to handle 
           //the fact there are invalid chars
           throw; 
       }
   }

   Cui poi si possono chiamare, come:

   string fileName = "testFileName.jpg";
   bool hasImageExtension = fileName.HasImageExtension();

   In realtà, Percorso.GetExtension potrebbe anche buttare se il percorso contiene caratteri non validi
   Sì, hai ragione – totalmente rovine della mia risposta, tempo per un aggiornamento 😉

   OriginaleL’autore Town

4. 0

   Questo dovrebbe funzionare:

   public bool CheckFileType(string FileName)
   {
       try
       {
           string Ext = Path.GetExtension(FileName).ToLower();
           string[] okExt = ".gif|.jpg|.jpeg|.png|.bmp".Split('|');
   
           foreach(var item in okExt)
           {
               if(Ext == item)
                   return true;
           }
           return false;
       }
       catch(Exception ex)
       {
           throw;
       }
   }

   E ricordate: mai intercettare le eccezioni non si sta andando a gestire. (o almeno di ri-lanciare loro)

   Altrimenti return false; è quello che mi manca.
   Dov’è il try/catch? Sembra di aver risolto il problema sbagliato.
   Risolti i problemi di cui sopra.
   O, si potrebbe utilizzare LINQ: return ".gif|.jpg|.jpeg|.png|.bmp".Split('|').Any(e => e.Equals(Ext));.
   Penso che questo potrebbe essere più chiaro; return nuovo Elenco<string> { “.gif”, “.jpeg”, “.jpg”, “.png”, “.bmp” }.Contiene(ext);

   OriginaleL’autore data