Question

我编写了一个与WCF服务一起使用的扩展方法，它将所有处理和异常处理逻辑保存在一个地方。方法如下：

public static TResult CallMethod<TChannel, TResult>(
    this ClientBase<TChannel> proxy,
    Func<TResult> func) where TChannel : class
{
    proxy.ThrowIfNull("proxy");
    func.ThrowIfNull("func");

    try
    {
        // set client credentials
        return func();
    }
    finally
    {
        if (proxy != null)
        {
            try
            {
                if (proxy.State != CommunicationState.Faulted)
                {
                    proxy.Close();
                }
                else
                {
                    proxy.Abort();
                }
            }
            catch (CommunicationException)
            {
                proxy.Abort();
            }
            catch (TimeoutException)
            {
                proxy.Abort();
            }
            catch (Exception)
            {
                proxy.Abort();
                throw;
            }
        }
    }
}

该方法将使用如下：

public int CreateBusinessObject(BusinessObject item)
{
    MyServiceClient proxy = new MyServiceClient();
    return proxy.CallMethod(() => proxy.CreateBusinessObject(item));
}

我的问题是，这是否会更好地作为创建服务代理的静态方法？我有点担心我目前的实施情况。代理的构造是否应该在try / catch中？我目前的理解是，如果构造函数失败，无论如何都没有什么可以处理的。

Answer 1

如果构造函数失败，则整个对象处于无效状态。在这种情况下，你不应该担心处置。

对此的一个很好的测试是执行以下操作时会发生什么：

class Program
{
    static void Main(string[] args)
    {
        using (new TestClass())
        {
            Console.WriteLine("In using");
        }
    }

    class TestClass : IDisposable
    {
        public TestClass()
        {
            throw new Exception();
        }

        public void Dispose()
        {
            Console.WriteLine("Disposed");
        }
    }
}

结果是永远不会达到处置。当构造函数失败时会发生这种情况。

使用扩展方法调用WCF服务

1 个答案: