如何在出现某个重大问题时可以越级上报?

Question

举个简单的例子.
主程序是一个解方程的题,下面有好几个函数,子函数,子子函数等等,还存在1级调用返回,2级调用返回,递归调用返回等. 
这时,我想在最内部一个环节中,如果发现出现无解的情况(概率非常小,但是存在),不管现在是在被哪个函数几级调用,都直接返回主程序汇报.
如果一级一级的return,就要加很多的bool变量,增加无数的判断,有可能返回上级后还会继续N次无意义的循环等.
请教有什么好的方法么? 我原来想在出现无解的时候threw一个错误,在主程序中catch住.那么在所有的函数中的try/catch如何能一路绿灯直接放到主程序中呢?

Answer 1

自定义Exception的类型,主程序的catch中对此类异常做处理
子函数的try-catch不要使用通用的异常捕捉
这样如果子函数抓不到异常,自然会抛出到上一级

Answer 2

不知道你说的用goto行不行,我知道这东西但基本上没实际应用过-_-!

Answer 3

那个，这个
如果不是递归的话，直接return就可以阻止，你还可以在return前加上一个事件触发通知错误处理项。如果是递归，好像没啥好的处理方式，貌似可以用一个被人遗忘的东西处理，goto，呵呵，没在 c#里用过goto，不过记忆中c#是保留goto这种写法滴

Answer 4

goto在方法里调用方法的情况下是跳不到主方法的.编译都通不过.

Answer 5

如果要用TRY/CATCH的话，自己定义异常类，抛出，最外层捕获。不过多级调用还有递归的,用TRY/CATCH好像开销蛮大的。

Answer 6

最近在看Workflow,LZ可以试试用Workflow做

Answer 7

谢谢大家,winform的.最好不要goto.呵呵.2楼的和我的想法差不多,我先努力试试.

Answer 8

我看能否这样：
1、定义一个Exception，比如：class MyException : Exception { }2、在子子函数里：if (xxx) throw new MyException();3、在子函数里：try
{
  // ...
}
catch
{
   throw;
}4、在最外层：try
{
}
catch (MyException ex)
{
   // 原来是子子函数出错了
}
catch (Exception ge)
{
   Console.WriteLine(ge.Message);
}
不知这样的效果是否可以

Answer 9

我感觉这恐怕不是一个语法的游戏了……return也好，throw也罢，都是按照Call的顺序向上传播的
你可能需要更改你的程序结构，从瀑布模式改成总线模式简单想了一下，用这种结构
/*
调用者
 |
 +-----模块1
 |
 +-----模块2
 |
 +-----模块3
 |
 +-----模块4
*/
调用者可以发起调用，也可以取消模块用下面这样的接口 public interface ICancelableTask {
   void BeginInvoke();
   void Cancel();
 }
....临时想的，仅供参考，有理解错误大家别打击我

Answer 10

你用的是.NET，而不是C/C++，不是吗？
象.NET、Java这些，更重视结构与代码安全，执行效率一般是放在第二位的
逐级返回是有必要的//加很多的bool变量,增加无数的判断
这些本来就应该有的吧

Answer 11

viena MM我怎么找不到你的MSN了…………

Answer 12

借用观察者模式的思想，搞一个第三方独立类作为观察者。    public delegate void ExceptionHandlerDelegate(Exception e);    public class MyException : Exception
    {
        //your exception
    }     public class ExceptionObserver
    {
        public event ExceptionHandlerDelegate OnExceptionCatch;
        public event ExceptionHandlerDelegate OnMyExceptionCatch;        private static ExceptionObserver _instance;        private ExceptionObserver()
        {
            //do nothing
        }        public static ExceptionObserver CreateInstance()
        {
            if (_instance == null)
            {
                _instance =new ExceptionObserver();
            }
            return _instance;
        }        public void ThrowException(Exception e)
        {
            if (e is MyException)
            {
                if (OnMyExceptionCatch != null)
                {
                    OnMyExceptionCatch(e);
                }
            }
            else
            {
                if (OnExceptionCatch != null)
                {
                    OnExceptionCatch(e);
                }
            }
        }
    }    public class MainClass
    {
        static void Main()
        {
            ExceptionObserver ob = ExceptionObserver.CreateInstance();
            ob.OnMyExceptionCatch += new ExceptionHandlerDelegate(ob_OnMyExceptionCatch);
            //do your work
            WorkClass worker = new WorkClass();
            worker.DoWork();
        }        static void ob_OnMyExceptionCatch(Exception e)
        {
            Console.WriteLine(e.Message);
        }
    }    public class WorkClass
    {
        public void DoWork()
        {
            ExceptionObserver ob = ExceptionObserver.CreateInstance();
            try
            {
                throw new MyException();                
            }
            catch (MyException e)
            {
                ob.ThrowException(e);
            }
            catch(Exception e)
            {
                throw e;
            }
        }
    }