我正在为WCF调用(使用BackgroundWorker)编写某种包装器,以便在调用正在进行时保持GUI不冻结.它主要是按预期工作,但是当WCF调用抛出异常时,我遇到了BackgroundWorker的问题.如果在DoWork中发生异常,我可以在RunWorkCompleted中检测到它,但是将其重新抛出到GUI不起作用.我已经读了很多线程,人们提到这应该有效.

包装器的代码(注意WCF调用由抛出的异常表示)：

private void GetSomething(Action<IEnumerable<int>> completedAction)
{
    BackgroundWorker b = new BackgroundWorker();

    b.DoWork += (s,evt) => { throw new Exception(); evt.Result = new List<int> { 1,2,3 }; };

    b.RunWorkerCompleted += (s,evt) =>
    {
        if (evt.Error == null && completedAction != null)
        {
           completedAction((IEnumerable<int>)evt.Result);
        }
        else if(evt.Error != null)
        {
           throw evt.Error;
        }
    };

    b.RunWorkerAsync();
}

在Windows窗体中调用代码：

private void button3_Click(object sender,EventArgs e)
{
    try
    {
        GetSomething(list =>
        {
           foreach (int i in list)
           {
              listView1.Items.Add(new ListViewItem(i.ToString()));
           }
        });
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
}

在调试时,我得到：

1. “Exception of type ‘System.Exception’ was thrown” in DoWork
2. “Exception of type ‘System.Exception’ was thrown” at throw evt.Error
3. “TargetInvocationException was unhandled” at Application.Run(new Form1()) in the Main method

我究竟做错了什么？我想在Windows窗体中捕获异常.

事件b.RunWorkerCompleted是您应该进行错误处理的地方.您可以传递一个Action< Exception>做错误处理就像

private void GetSomething(Action<IEnumerable<int>> completedAction,Action<Exception> exceptionAction)
{
    BackgroundWorker b = new BackgroundWorker();

    b.DoWork += (s,evt) =>
    {
        if (evt.Error == null && completedAction != null)
            completedAction((IEnumerable<int>)evt.Result);
        else if(evt.Error != null)
            exceptionAction(evt.Error);
    };

    b.RunWorkerAsync();
}

然而,这往往会变得丑陋.如果您使用.Net 4或4.5,则可以使用“任务”.任务< TResult>是为了这种情况而创建的：

Task<IEnumerable<int>> GetSomething()
{
    return Task.Factory.StartNew(() => { 
        Thread.Sleep(2000);
        throw new Exception(); 
        return (new List<int> { 1,3 }).AsEnumerable(); 
        });
}

任务基本上是一个信号构造

> a.结果财产
> .Exception属性
> a .ContinueWith()方法

在ContinueWith()中,您可以检查Task是否处于故障状态(Exception被抛出).

你可以像使用它一样

private void button3_Click(object sender,EventArgs e)
    {
        GetSomething()
            .ContinueWith(task =>
                {
                    if (task.IsCanceled)
                    {
                    }
                    else if (task.IsFaulted)
                    {
                        var ex = task.Exception.InnerException;
                        MessageBox.Show(ex.Message);
                    }
                    else if (task.IsCompleted)
                    {
                        var list = task.Result;
                        foreach (int i in list)
                        {
                            listView1.Items.Add(new ListViewItem(i.ToString()));
                        }
                    }
                });
    }

如果您使用.Net 4.5和C#5(您需要VS2012或VS2010和Async CTP),您甚至可以使用异步并等待

private async void button3_Click(object sender,EventArgs e)
    {
        try
        {
            var list = await GetSomething();
            foreach (int i in list)
            {
                listView1.Items.Add(new ListViewItem(i.ToString()));
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }

……所有的魔力都是由编译器完成的.请注意,您可以像以前一样使用try catch.

我想编写一个处理异常的方法,它将在catch块中调用.根据传递的异常的类型,异常要么作为新异常的内部异常传递,要么只是重新抛出.如何在第二种情况下保留堆栈跟踪？

示例：

public void TestMethod()
{
    try
    {
        // can throw an exception specific to the project or a .Net exception 
        SomeWorkMethod() 
    }
    catch(Exception ex)
    {
        HandleException(ex);
    }
}

private void HandleException(Exception ex)
{
    if(ex is SpecificException)
         throw ex; //will not preserve stack trace...
    else
         throw new SpecificException(ex);
}

我不想做的是,因为模式在很多地方重复,并且没有因子分解：

try
{
    SomeWorkMethod();
}
catch(Exception ex)
{
    if(ex is SpecificException)
         throw;
    else
         throw new SpecificException(ex);
}

您需要在不指定异常的情况下使用throw来保留堆栈跟踪.这只能在catch块内完成.你可以做的是从HandleException返回而不抛出原始异常,然后使用throw：

public void TestMethod()
{
    try
    {
        // can throw an exception specific to the project or a .Net exception 
        SomeWorkMethod() 
    }
    catch(Exception ex)
    {
        HandleException(ex);
        throw;
    }
}

private void HandleException(Exception ex)
{
    if(ex is SpecificException)
         return;
    else
         throw new SpecificException(ex);
}

只要您只使用is来对异常进行分类,首选方法是两个catch块：

public void TestMethod()
{
    try
    {
        // can throw an exception specific to the project or a .Net exception 
        SomeWorkMethod() 
    }
    catch (SpecificException)
    {
        throw;
    }
    catch(Exception ex)
    {
        throw new SpecificException(ex);
    }
}

使用C#6.0,您还可以使用何时让异常通过：

public void TestMethod()
{
    try
    {
        // can throw an exception specific to the project or a .Net exception 
        SomeWorkMethod() 
    }
    catch(Exception ex) when (!(ex is SpecificException))
    {
        throw new SpecificException(ex);
    }
}

当数据库大小指定大于5 MB时,open Database()方法会在iPad 4.3以及所有iOS Simulator 4.x上引发异常(Security_ERR：DOM异常18).

使用PhoneGap 1.0.0在XCode 4.2(Mac OS X 10.6.8)下进行编译.

我们可以绕过这个限制吗？

这是一个示例代码：

<!DOCTYPE html> 
<html> 
<head> 
    <script src="phonegap-1.0.0.js"></script>
    <script>        
        try {
            var db = window.openDatabase("TMA","1.0","TMA Mobile Database",1024 * 1024 * 10);
        } catch (err) {
            alert(err);
        }
    </script> 
    <Meta name="viewport" content="width=320; initial-scale=1.0; maximum-scale=1.0; user-scalable=0;" />
</head> 
<body> 

</body>
</html>

根据 this resource,iOS本身的最大尺寸为5mb.一旦达到5mb大小,它将询问用户是否希望它变大.

我怀疑它有什么好办法.

您是否尝试过创建多个数据库？也许两个5mb DB可以为你工作.