Wyrażenia lambda w praktyce – MethodWrappers

  1:  try
  2:  {
  3:  	CanThrow();
  4:  }
  5:  catch
  6:  {
  7:  }
  8:  try
  9:  {
 10:  	WillPossiblyThrowException();
 11:  }
 12:  catch
 13:  {
 14:  
 15:  }
 16:  try
 17:  {
 18:  	ShouldNotThrowButWhoKnows();
 19:  }
 20:  catch
 21:  {
 22:  
 23:  }

  1:  MethodWrappers.IgnoreExceptions(
  2:  	CanThrow,
  3:  	WillPossiblyThrowException,
  4:  	ShouldNotThrowButWhoKnows
  5:  	);

  1:  /// <summary>
  2:  /// Executes given operations catching all exceptions.
  3:  /// Exceptions thrown by the operations are ignored and do not bubble up to the caller.
  4:  /// Exceptions do not prevent other operations from being executed.
  5:  /// </summary>
  6:  public static void IgnoreExceptions(params Action[] operations)
  7:  {
  8:  	foreach (var operation in operations)
  9:  	{
 10:  		try
 11:  		{
 12:  			operation();
 13:  		}
 14:  		catch
 15:  		{
 16:  		}
 17:  	}
 18:  }

  1:  try
  2:  {
  3:  	CanThrow();
  4:  }
  5:  catch
  6:  {
  7:  	Hilfe();
  8:  }
  9:  try
 10:  {
 11:  	WillPossiblyThrowException();
 12:  }
 13:  catch
 14:  {
 15:  	Rollback();
 16:  }
 17:  try
 18:  {
 19:  	ShouldNotThrowButWhoKnows();
 20:  }
 21:  catch
 22:  {
 23:  	Log();
 24:  }

  1:  MethodWrappers.ExecuteTryCatch(CanThrow, Hilfe);
  2:  MethodWrappers.ExecuteTryCatch(WillPossiblyThrowException, Rollback);
  3:  MethodWrappers.ExecuteTryCatch(ShouldNotThrowButWhoKnows, Log);

  1:  /// <summary>
  2:  /// Executes the <paramref name="tryOperation"/> and performs the <paramref name="catchOperation"/> in case of exception.
  3:  /// </summary>
  4:  /// <param name="tryOperation">Operation to be executed.</param>
  5:  /// <param name="catchOperation">Operation to be executed in case of exception.</param>
  6:  public static void ExecuteTryCatch(Action tryOperation, Action catchOperation)
  7:  {
  8:  	try
  9:  	{
 10:  		tryOperation();
 11:  	}
 12:  
 13:  	catch
 14:  	{
 15:  		catchOperation();
 16:  	}
 17:  }

  1:  List<int> positiveResults = new List<int>();
  2:  int temp = FirstOperationReturningInt();
  3:  if (temp >= 0)
  4:  	positiveResults.Add(temp);
  5:  temp = Sum(1, 2);
  6:  if (temp >= 0)
  7:  	positiveResults.Add(temp);

  1:  List<int> positiveResults = MethodWrappers.AggregateResults(
  2:  	number => number >= 0,
  3:  	FirstOperationReturningInt,
  4:  	() => Sum(1, 2)
  5:  	);

  1:  /// <summary>
  2:  /// Executes each operation and creates an array of their results if.
  3:  /// Only results that satisfy a given condition are aggregated.
  4:  /// </summary>
  5:  /// <typeparam name="T">Type of a value returned by each of the actions.</typeparam>
  6:  /// <param name="condition">Condition that must be satisfied for the result to be aggregated.</param>
  7:  /// <param name="operations">Array of aggregated results of the operations.</param>
  8:  public static List<T> AggregateResults<T>(Predicate<T> condition, params Func<T>[] operations)
  9:  {
 10:  	List<T> results = new List<T>(operations.Length);
 11:  
 12:  	foreach (var operation in operations)
 13:  	{
 14:  		T result = operation();
 15:  		if (condition == null || condition(result))
 16:  			results.Add(result);
 17:  	}
 18:  
 19:  	return results;
 20:  }