如何引发异常并继续循环（或如何从一个循环引发许多异常）

Question

I have two method and for me need to generate exception from one to another some like this

public void Method1()
{ 
    try
    {  
        Method2(1);
    }
    catch(Exception e )
    {
        SendEmail (/* some message */)
    }
}

public IEnumerable<int> Method2(int id)
{
    foreach (var i in col)
    {
        try
        { 
            /*Do some stuff*/ 
            yield return i 
        }
       catch
       {
           /* delegate this exception to Method1 and continue foreach loop */
       }            
    }
 }

How to delegate exception from Method 2 to Method 1 and continue foreach loop in method 2

UPD:

And how about

for example : Method 1 -> Method3 -> Method2 -> method 2 return exception in method 1

UPD2: to UPD

   /*Call*/
        var i = new List<int>() {0, 0, 0, 0, 0, 0, 7, 0, 9};
        Calc(i, SendMessage);


   public static void SendMessage(Exception ex)
    {
        Console.WriteLine(ex.ToString());
    }

    public static double Calc(List<int> list, Action<Exception> callback)
    {
        var a = 0.00;
        foreach (var i in list)
        {
            try
            {
                a = Calc1(i);/*if here (double)7 / i it's just works but in how to include in method*/
            }
            catch (Exception ex)
            {
                callback(ex);
            }
        }
        return a;
    }

    public static double Calc1(int i)
    {
        var a = 0.00;
        a = (double)7 / i;
        return a;
    }

Answer 1

1. You can't have yield return inside try/catch.

2. You can do it this way if you really want to do it but I don't really recommend this approach. Exceptions should be handled when and where they are thrown or should be re-thrown in my opinion.

    public void Method1() { Method2(1, ex => SendEmail(ex)); } public IEnumerable<int> Method2(int id, Action<Exception> callback) { foreach (var i in new List<int>()) { try { /*Do some stuff*/ } catch(Exception ex) { callback(ex); } yield return i; } } private void SendEmail(Exception ex) { // blah } 

Answer 2

You cannot. Once an exception is thrown back to Method1 , Method2 cannot continue.

What you can do, however, is give Method2 a callback function that handles the exceptions.

public IEnumerable<int> Method2(Func<Exception, bool> handler)
{
    foreach (var item in collection)
    {
        try
        {
            // ...
        }
        catch (Exception ex)
        {
            if (!handler(ex))
                throw;
        }
    }
}

Now Method1 can pass a function that gets an exception, and returns whether it has handled that exception. If it has, the loop continues.

Answer 3

As noted in the other answers, you can't " yield throw " an exception. One workaround would be to catch the exception and return an object that includes it. (eg a KeyValuePair<int, Exception> )

public void Method1()
{
    foreach(var i in Method2(1))
    {
        if (i.Value == null)
        {
            // No Exception Thrown
        }
        else
        {
            // Exception Thrown
            SendEmail(); // Send a message
        }
    }       
}

public IEnumerable<KeyValuePair<int, Exception>> Method2(int id)
{
    List<int> col = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    Exception exception;

    foreach (var i in col)
    {
        exception = null;
        try
        { 
            if ((i % 2) == 1)
            {
                throw new Exception("Test" + i);
            }
            /*Do some stuff*/
        }
        catch (Exception ex)
        {
            exception = ex;
        }

        yield return new KeyValuePair<int, Exception>(i, exception);
    }
}