Try-Catch mit fließend Ausdrücke

Question

Dieser LINQ-Abfrage-Ausdruck nicht mit Win32Exception "Zugriff wird verweigert ":

Process.GetProcesses().Select(p => p.MainModule.FileName) 

Und das nicht mit IOException" Das Gerät ist nicht bereit":

DriveInfo.GetDrives().Select(d => d.VolumeLabel) 

Was ist der beste Weg, um unzugängliche Objekte herauszufiltern und Ausnahmen zu vermeiden?

Answer 1

Schreiben Sie eine Erweiterungsmethode!

void Main() 
{ 
    var volumeLabels = 
     DriveInfo 
     .GetDrives() 
     .SelectSafe(dr => dr.VolumeLabel); 
} 

// Define other methods and classes here 

public static class LinqExtensions 
{ 
    public static IEnumerable<T2> SelectSafe<T,T2>(this IEnumerable<T> source, Func<T,T2> selector) 
    { 
     foreach (var item in source) 
     { 
      T2 value = default(T2); 
      try 
      {   
       value = selector(item); 
      } 
      catch 
      { 
       continue; 
      } 
      yield return value; 
     } 
    } 
} 

diese Weise können Sie jedes Verhalten anpassen können Sie wollen, und Sie haben zu sperrig und Hacky where-Klauseln nicht zu schaffen, auf diese Weise Sie es sogar einen alternativen Wert bekommen könnte zurückkehren, wenn eine Ausnahme gibt.

Answer 2

Insert eine WHERE-Filter (die jedes Objekt zuzugreifen versucht, und absorbiert den möglichen Zugriffsfehler) mit:

{ try { var x = obj.MyProp; return true; } catch { return false; } }: 

erste Ausdruck:

Process 
    .GetProcesses() 
    .Where(p => { try { var x = p.MainModule; return true; } catch { return false; } }) 
    .Select(p => p.MainModule.FileName) 

zweite Ausdruck:

DriveInfo 
    .GetDrives() 
    .Where(d => { try { var x = d.VolumeLabel; return true; } catch { return false; } }) 
    .Select(d => d.VolumeLabel) 

Answer 3

Ich würde für das erste Szenario versuchen:

//Declare logger type 
private readonly ILog _log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); 

Process.GetProcesses() 
.Where(p => { 
    try { 
     var x = p.MainModule; 
     return true; 
    } 
    catch(Win32Exception e2) 
    { IgnoreError(); } 
    }) 
.Select(p => p.MainModule.FileName) 

public static void IgnoreError(Exception e) 
{ 
    #if DEBUG 
    throw e2; 
    //Save the error track, I prefer log4net 
    _log.Info("Something bad happened!"); 
    #end if 
} 

Und für das zweite Szenario, würde ich eher lieber eine IF und speichern Sie das Protokoll verwenden:

//Somewhere in the begging of your class, in a place whose name I do not care to remember ... 
//Declare logger type 
private readonly ILog _log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); 


public List<string> VolumenLabels() 
{ 
    //Return the List<T> 
    List<string> myVolumeLabels = new List<string>(); 
    //Getting the info 
    DriveInfo[] allDrives = DriveInfo.GetDrives(); 

    foreach(DriveInfo drive in allDrives) 
    { 
     if (drive.IsReady == true) 
     { 
      myVolumeLabels.Add(drive.VolumeLabel.ToString()); 
     } 
     else 
     { 
      _log.Info("Check the Drive: " + drive.Name + " the device is not ready."); 
     } 
    }  
    return myVolumeLabels; 
} 

Ich hoffe, ich habe ein wenig geholfen ... einen schönen Tag!

Answer 4

Ihre Antwort ist die richtige. Sie können natürlich versuchen, die Prüflogik in einer Erweiterungsmethode zu verbergen.

public static IEnumerable<TElement> WhereSafe<TElement, TInner>(this IEnumerable<TElement> sequence, Func<TElement, TInner> selector) 
{ 
    foreach (var element in sequence) 
    { 
     try { selector(element); } 
     catch { continue; } 
     yield return element; 
    } 
} 


Process 
    .GetProcesses() 
    .WhereSafe(p => p.MainModule) 
    .Select(p => p.MainModule.FileName) 

Oder besser so:

public static IEnumerable<TInner> TrySelect<TElement, TInner>(this IEnumerable<TElement> sequence, Func<TElement, TInner> selector) 
{ 
    TInner current = default(TInner); 
    foreach (var element in sequence) 
    { 
     try { current = selector(element); } 
     catch { continue; } 
     yield return current; 
    } 
} 


Process 
    .GetProcesses() 
    .TrySelect(p => p.MainModule.FileName) 

Answer 5

aktualisieren, basierend auf Kommentare: Diese Lösung funktioniert nicht mit gemeinsamen Aufzählungen arbeiten. Es funktioniert auf der Grundlage der in den Beispielen der Frage verwendeten Enumeratoren. Daher ist es keine generische Lösung. Da es als allgemeine Lösung geschrieben wurde, rate ich davon ab, dies zu verwenden (um die Dinge einfach zu halten). Ich werde diese Antwort behalten, um die Wissensbasis zu bereichern.

Eine andere Extension-Methode Lösung. Warum bevorzuge ich es gegenüber den bestehenden Lösungen?

• Wir wollen Elemente überspringen, die nur Ausnahmen verursachen. Dies ist das einzige Anliegen unserer LINQ-Erweiterung.
• Diese Implementierung vermischt nicht die Bedenken von Select und try/catch.
• Wir können weiterhin vorhandene LINQ-Methoden wie Select bei Bedarf verwenden.
• Es ist wiederverwendbar: es ermöglicht mehrere Nutzungen innerhalb einer LINQ-Abfrage.
• Es folgt Linq Namenskonventionen: Wir überspringen tatsächlich ähnlich wie Skip und SkipWhile Methoden.

Verbrauch:

var result = DriveInfo 
    .GetDrives() 
    .Select(d => d.VolumeLabel) 
    .SkipExceptions() // Our extension method 
    .ToList(); 

Code:

public static class EnumerableExt 
{ 
    // We use the `Skip` name because its implied behaviour equals the `Skip` and `SkipWhile` implementations 
    public static IEnumerable<TSource> SkipExceptions<TSource>(this IEnumerable<TSource> source) 
    { 
     // We use the enumerator to be able to catch exceptions when enumerating the source 
     using (var enumerator = source.GetEnumerator()) 
     { 
      // We use a true loop with a break because enumerator.MoveNext can throw the Exception we need to handle 
      while (true) 
      { 
       var exceptionCaught = false; 
       var currentElement = default(TSource); 
       try 
       { 
        if (!enumerator.MoveNext()) 
        { 
         // We've finished enumerating. Break to exit the while loop        
         break; 
        } 

        currentElement = enumerator.Current; 
       } 
       catch 
       { 
        // Ignore this exception and skip this item. 
        exceptionCaught = true; 
       } 

       // Skip this item if we caught an exception. Otherwise return the current element. 
       if (exceptionCaught) continue; 

       yield return currentElement; 
      } 
     } 
    } 
}