[C#] WCF 클라이언트`사용`블록 문제에 대한 가장 좋은 해결 방법은 무엇입니까?

using구현하는 리소스를 사용하는 표준 방법과 거의 비슷하기 때문에 블록 내에서 WCF 서비스 클라이언트를 인스턴스화 하는 것이 좋습니다 IDisposable.

using (var client = new SomeWCFServiceClient()) 
{
    //Do something with the client 
}

그러나이 MSDN 기사 에서 언급 한 것처럼 WCF 클라이언트를 using블록 에 래핑 하면 클라이언트가 오류 상태 (시간 초과 또는 통신 문제 등)로 남아있는 오류를 숨길 수 있습니다. 간단히 말해 Dispose ()가 호출되면 클라이언트의 Close () 메서드가 실행되지만 오류가 발생한 상태에서 오류가 발생합니다. 그런 다음 원래 예외는 두 번째 예외에 의해 가려집니다. 안좋다.

MSDN 기사에서 제안 된 해결 방법은 using블록 사용을 완전히 피하고 대신 클라이언트를 인스턴스화하고 다음과 같이 사용하는 것입니다.

try
{
    ...
    client.Close();
}
catch (CommunicationException e)
{
    ...
    client.Abort();
}
catch (TimeoutException e)
{
    ...
    client.Abort();
}
catch (Exception e)
{
    ...
    client.Abort();
    throw;
}

using블록과 비교하면 추악하다고 생각합니다. 그리고 클라이언트가 필요할 때마다 쓸 많은 코드가 있습니다.

운 좋게도 IServiceOriented에서 이와 같은 몇 가지 해결 방법을 찾았습니다. 당신은 시작합니다 :

public delegate void UseServiceDelegate<T>(T proxy); 

public static class Service<T> 
{ 
    public static ChannelFactory<T> _channelFactory = new ChannelFactory<T>(""); 

    public static void Use(UseServiceDelegate<T> codeBlock) 
    { 
        IClientChannel proxy = (IClientChannel)_channelFactory.CreateChannel(); 
        bool success = false; 
        try 
        { 
            codeBlock((T)proxy); 
            proxy.Close(); 
            success = true; 
        } 
        finally 
        { 
            if (!success) 
            { 
                proxy.Abort(); 
            } 
        } 
     } 
} 

그러면 다음이 가능합니다.

Service<IOrderService>.Use(orderService => 
{ 
    orderService.PlaceOrder(request); 
}); 

나쁘지는 않지만 using블록 처럼 표현적이고 쉽게 이해할 수 있다고 생각하지 않습니다 .

현재 사용하려는 해결 방법은 blog.davidbarret.net 에서 처음 읽은 것입니다 . 기본적으로 클라이언트의 Dispose()메소드를 사용하는 모든 위치 에서 대체합니다 . 다음과 같은 것 :

public partial class SomeWCFServiceClient : IDisposable
{
    void IDisposable.Dispose() 
    {
        if (this.State == CommunicationState.Faulted) 
        {
            this.Abort();
        } 
        else 
        {
            this.Close();
        }
    }
}

이는 using결함이있는 상태 예외를 마스킹 할 위험없이 블록을 다시 허용 할 수있는 것으로 보입니다 .

따라서이 해결 방법을 사용할 때 고려해야 할 다른 문제가 있습니까? 아무도 더 나은 것을 생각해 냈습니까?

답변

Service<IOrderService>.Use(orderService=>
{
  orderService.PlaceOrder(request);
}); 

int newOrderId = 0; // need a value for definite assignment
Service<IOrderService>.Use(orderService=>
  {
    newOrderId = orderService.PlaceOrder(request);
  });
Console.WriteLine(newOrderId); // should be updated

void IDisposable.Dispose()
{
    bool success = false;
    try
    {
        if (State != CommunicationState.Faulted)
        {
            Close();
            success = true;
        }
    }
    finally
    {
        if (!success)
            Abort();
    }
}

TReturn UseService<TChannel, TReturn>(Func<TChannel, TReturn> code)
{
    var chanFactory = GetCachedFactory<TChannel>();
    TChannel channel = chanFactory.CreateChannel();
    bool error = true;
    try {
        TReturn result = code(channel);
        ((IClientChannel)channel).Close();
        error = false;
        return result;
    }
    finally {
        if (error) {
            ((IClientChannel)channel).Abort();
        }
    }
}

int a = 1;
int b = 2;
int sum = UseService((ICalculator calc) => calc.Add(a, b));
Console.WriteLine(sum);

try
{
    ...
    double result = client.Add(value1, value2);
    ...
    client.Close();
}
catch (TimeoutException exception)
{
    Console.WriteLine("Got {0}", exception.GetType());
    client.Abort();
}
catch (CommunicationException exception)
{
    Console.WriteLine("Got {0}", exception.GetType());
    client.Abort();
}

  // The following is typically thrown on the client when a channel is terminated due to the server closing the connection.
catch (ChannelTerminatedException cte)
{
secureSecretService.Abort();
// todo: Implement delay (backoff) and retry
}

// The following is thrown when a remote endpoint could not be found or reached.  The endpoint may not be found or 
// reachable because the remote endpoint is down, the remote endpoint is unreachable, or because the remote network is unreachable.
catch (EndpointNotFoundException enfe)
{
secureSecretService.Abort();
// todo: Implement delay (backoff) and retry
}

// The following exception that is thrown when a server is too busy to accept a message.
catch (ServerTooBusyException stbe)
{
secureSecretService.Abort();
// todo: Implement delay (backoff) and retry
}

public static class UsingServiceClient
{
    public static void Do<TClient>(TClient client, Action<TClient> execute)
        where TClient : class, ICommunicationObject
    {
        try
        {
            execute(client);
        }
        finally
        {
            client.DisposeSafely();
        }
    }

    public static void DisposeSafely(this ICommunicationObject client)
    {
        if (client == null)
        {
            return;
        }

        bool success = false;

        try
        {
            if (client.State != CommunicationState.Faulted)
            {
                client.Close();
                success = true;
            }
        }
        finally
        {
            if (!success)
            {
                client.Abort();
            }
        }
    }
}

string result = string.Empty;

UsingServiceClient.Do(
    new MyServiceClient(),
    client =>
    result = client.GetServiceResult(parameters));

public static TResult Using<T, TResult>(this T client, Func<T, TResult> work)
        where T : ICommunicationObject
{
    try
    {
        var result = work(client);

        client.Close();

        return result;
    }
    catch (Exception e)
    {
        client.Abort();

        throw;
    }
}