WCF: Basisklasse für einen Proxy

Hallo zusammen,

die Proxies sind nur für das Erstellen der Channel und der ICommunication-Objekte zuständig. D.h. es lassen sich auch asynchrone Vorgänge damit bewerkstelligen, da dies eben unabhängig vom Proxy an sich ist.

Mit .net 4.0 und speziell mit den Tasks lassen sich asynchrone Methoden für WCF sehr einfach bewerkstelligen, da Task die Schnittstelle IAsyncResult implementiert. Auf eine allgemeine Übersicht über asynchrone Vorgänge in WCF verzichte ich und verweise auf  Synchronous and Asynchronous Operations. Hier weise ich nur darauf hin, dass es verschiedene Möglichkeiten der Asynchronizität in WCF gibt:

• Server asynchron und Client asynchron
  
• Server asynchron und Client synchron
  
• Server synchron und Client asynchron

Der Server sollte vorzugsweise dann asynchron laufen, wenn dieser als "Zwischenschicht" dient, z.B. wenn die Servicemethode einen weiteren Service, etc. aufruft. Dies erhöht den Durchsatzt und die Skalierbarkeit.
Der Client sollte dann asynchron laufen wenn z.B.  [FAQ] Warum blockiert mein GUI? ein Problem sein könnte.

Die Implementierung eines asynchronen Vorgangs zeige ich an einem Beispiel. Angenommen wir haben folgenden ServiceContract:

C#-Code (ServiceContract):

using System; using System.ServiceModel; namespace Contracts {     [ServiceContract]     public interface IMyService     {         [OperationContract]         int Add(int a, int b);         //---------------------------------------------------------------------         [OperationContract(AsyncPattern = true)]         IAsyncResult BeginAddAsync(int a, int b, AsyncCallback callback, object state);         int EndAddAsync(IAsyncResult ar);     } }

Der Service kann dann wie folgt implementiert werden.

C#-Code (Service):

using System; using System.Threading.Tasks; using Contracts; using gfoidl.Service.Utils; namespace Service {     public class MyService : IMyService     {         #region IMyService Members         public int Add(int a, int b)         {             return a + b;         }         //---------------------------------------------------------------------         public IAsyncResult BeginAddAsync(int a, int b, AsyncCallback callback, object state)         {             var task = Task.Factory.StartNew(() => this.Add(a, b));             task.ContinueWith(                 t => Console.WriteLine(t.Exception),  // produktiv: besser Loggen                 TaskContinuationOptions.OnlyOnFaulted);             return task.ToApm(callback, state);         }         //---------------------------------------------------------------------         public int EndAddAsync(IAsyncResult ar)         {             return ar.End<int>();         }         #endregion     } }

Und der Client schaut so aus:

C#-Code (Client):

using System; using System.Collections.Generic; using System.Linq; using System.Text; using Contracts; using System.ServiceModel; using gfoidl.Service.Utils; using System.Threading.Tasks; namespace Client {     public interface IMyServiceClient : IMyService     {         Task<int> AddAsync(int a, int b);     }     //-------------------------------------------------------------------------     public interface IMyServiceClientChannel : IMyServiceClient, ICommunicationObject { }     //-------------------------------------------------------------------------     public class MyServiceClient : ProxyBase<IMyServiceClientChannel>, IMyServiceClient     {         public MyServiceClient(string endpointAddress)             : base(endpointAddress) { }         public MyServiceClient(string endpointAddress, Bindings bindings)             : base(endpointAddress, bindings) { }         //---------------------------------------------------------------------         #region IMyService Members         public int Add(int a, int b)         {             return this.Proxy.Add(a, b);         }         //---------------------------------------------------------------------         IAsyncResult IMyService.BeginAddAsync(int a, int b, AsyncCallback callback, object state)         {             return this.Proxy.BeginAddAsync(a, b, callback, state);         }         //---------------------------------------------------------------------         int IMyService.EndAddAsync(IAsyncResult ar)         {             return this.Proxy.EndAddAsync(ar);         }         //---------------------------------------------------------------------         public Task<int> AddAsync(int a, int b)         {             return TaskHelper.FromAsync(                 (this as IMyService).BeginAddAsync,                 (this as IMyService).EndAddAsync,                 a, b,                 this.Proxy);         }         #endregion     } }

Damit das Ganze elegant funktioniert sind ein paar Erweiterungsmethoden notwendig, die dem obigen Projekt hinzugefügt werden können. Ich poste hier die wiederverwendbaren Klassen, so wie ich sie (od. fast so) produktiv verwende, und diese beinhalten auch Überladungen für die gängigen Anwendungsfälle.

Zuerst werden Erweiterungsmethoden für Tasks benötigt, um das asynchrone Pattern (Begin/End, auch als APM...asynchronous programming model bezeichnet) mit den Task kompatibel zu machen:

C#-Code:

using System; using System.Diagnostics.Contracts; using System.Threading.Tasks; namespace System.Threading.Tasks {     public static partial class TaskExtensions     {         public static Task ToApm(             this Task task,             AsyncCallback callback,             object state)         {             Contract.Requires(task != null);             Contract.Requires(callback != null);             Contract.Ensures(Contract.Result<Task>() != null);             //-----------------------------------------------------------------             if (task.AsyncState == state)             {                 if (callback != null)                     task.ContinueWith(                         t => callback(t),                         TaskContinuationOptions.ExecuteSynchronously);                 return task;             }             var tcs = new TaskCompletionSource<object>(state);             task.ContinueWith(t =>             {                 if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions);                 else if (t.IsCanceled) tcs.TrySetCanceled();                 else tcs.TrySetResult(null);                 if (callback != null) callback(tcs.Task);             }, TaskContinuationOptions.ExecuteSynchronously);             return tcs.Task;         }         //---------------------------------------------------------------------         public static Task<TResult> ToApm<TResult>(             this Task<TResult> task,             AsyncCallback callback,             object state)         {             Contract.Requires(task != null);             Contract.Requires(callback != null);             Contract.Ensures(Contract.Result<Task<TResult>>() != null);             //-----------------------------------------------------------------             if (task.AsyncState == state)             {                 if (callback != null)                     task.ContinueWith(                         t => callback(t),                         TaskContinuationOptions.ExecuteSynchronously);                 return task;             }             var tcs = new TaskCompletionSource<TResult>(state);             task.ContinueWith(t =>             {                 if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions);                 else if (t.IsCanceled) tcs.TrySetCanceled();                 else tcs.TrySetResult(t.Result);                 if (callback != null) callback(tcs.Task);             }, TaskContinuationOptions.ExecuteSynchronously);             return tcs.Task;         }     } }

Genauso gibts eine Erweiterungsmethode um vom Task wieder zum APM zu gelangen:

C#-Code:

using System; using System.Diagnostics.Contracts; using System.ServiceModel; using System.Threading.Tasks; namespace gfoidl.Service.Utils {     public static class IAsyncResulstExtensions     {         // Da es streng kanonisch ist => Erweiterungsmethode :-)         public static T End<T>(this IAsyncResult ar)         {             if (!(ar is Task<T>)) throw new InvalidOperationException("Only Task<T> can be handeld.");             Contract.EndContractBlock();             //-----------------------------------------------------------------             var task = ar as Task<T>;             try             {                 return task.Result;             }             catch (AggregateException aex)             {                 throw EnsureFaultException(aex);             }         }         //---------------------------------------------------------------------         private static FaultException EnsureFaultException(AggregateException aex)         {             // ZB bei nested Tasks ist die InnerException auch eine AggregateException!             Exception ex = aex.GetRootException();             FaultException fex = ex as FaultException;             // Wenn es keine FaultException ist dann erstellen:             if (fex == null)             {                 Type genericType = typeof(FaultException<>);                 Type[] typeArgs = { ex.GetType() };                 Type type = genericType.MakeGenericType(typeArgs);                 fex = Activator.CreateInstance(type, ex, ex.Message) as FaultException;             }             return fex;         }     } }

Hierzu ist es auch notwendig die ExceptionExtensions, die im obigen Projekt dabei sind, zu erweitern. Der komplette Code für diese Klasse ist nun wie folgt:

C#-Code:

using System; using System.Diagnostics.Contracts; using System.ServiceModel; using System.Threading.Tasks; namespace gfoidl.Service.Utils {     public static class ExceptionExtensions     {         public static FaultException<T> ToFaultException<T>(this T ex)             where T : Exception         {             Contract.Requires(ex != null);             Contract.Ensures(Contract.Result<FaultException<T>>() != null);             //-----------------------------------------------------------------             return new FaultException<T>(ex, ex.Message);         }         //---------------------------------------------------------------------         public static FaultException<T> ToFaultException<T>(this Task task)             where T : Exception         {             Contract.Requires(task != null);             Contract.Ensures(Contract.Result<FaultException<T>>() != null);             //-----------------------------------------------------------------             return (task.Exception.InnerException as T).ToFaultException();         }         //---------------------------------------------------------------------         public static T FromFaultException<T>(this FaultException<T> ex)             where T : Exception         {             Contract.Requires(ex != null);             Contract.Ensures(Contract.Result<T>() != null);             //-----------------------------------------------------------------             return ex.Detail;         }         //---------------------------------------------------------------------         public static Exception GetRootException(this Exception ex)         {             Contract.Requires(ex != null);             //-----------------------------------------------------------------             return GetRootExceptionCore(ex);         }         //---------------------------------------------------------------------         private static Exception GetRootExceptionCore(Exception ex)         {             if (ex is AggregateException) return GetRootExceptionCore(ex.InnerException);             return ex;         }     } }

Für den Client brauchen wir auch noch Hilfs-Methoden um aus dem APM einen Task zu erzeugen, damit die Client-Verwendung ganz transparent wird. Dies geschieht in folgender Hilfsklasse:

C#-Code:

using System; using System.Diagnostics.Contracts; using System.ServiceModel; using System.Threading.Tasks; namespace gfoidl.Service.Utils {     public static class TaskHelper     {         public static Task<TResult> FromAsync<TArg1, TResult>(             Func<TArg1, AsyncCallback, object, IAsyncResult> beginMethod,             Func<IAsyncResult, TResult> endMethod,             TArg1 arg1,             object state)         {             Contract.Requires(beginMethod != null);             Contract.Requires(endMethod   != null);             //-----------------------------------------------------------------             TaskCompletionSource<TResult> tcs = new TaskCompletionSource<TResult>(state);             AsyncCallback callback = ar => FromAsyncCore(tcs, ar, endMethod);             beginMethod(arg1, callback, state);             return tcs.Task;         }         //---------------------------------------------------------------------         public static Task<TResult> FromAsync<TArg1, TArg2, TResult>(             Func<TArg1, TArg2, AsyncCallback, object, IAsyncResult> beginMethod,             Func<IAsyncResult, TResult> endMethod,             TArg1 arg1,             TArg2 arg2,             object state)         {             Contract.Requires(beginMethod != null);             Contract.Requires(endMethod   != null);             //-----------------------------------------------------------------             TaskCompletionSource<TResult> tcs = new TaskCompletionSource<TResult>(state);             AsyncCallback callback = ar => FromAsyncCore(tcs, ar, endMethod);             beginMethod(arg1, arg2, callback, state);             return tcs.Task;         }         //---------------------------------------------------------------------         public static Task<TResult> FromAsync<TArg1, TArg2, TArg3, TResult>(             Func<TArg1, TArg2, TArg3, AsyncCallback, object, IAsyncResult> beginMethod,             Func<IAsyncResult, TResult> endMethod,             TArg1 arg1,             TArg2 arg2,             TArg3 arg3,             object state)         {             Contract.Requires(beginMethod != null);             Contract.Requires(endMethod != null);             //-----------------------------------------------------------------             TaskCompletionSource<TResult> tcs = new TaskCompletionSource<TResult>(state);             AsyncCallback callback = ar => FromAsyncCore(tcs, ar, endMethod);             beginMethod(arg1, arg2, arg3, callback, state);             return tcs.Task;         }         //---------------------------------------------------------------------         private static void FromAsyncCore<TResult>(             TaskCompletionSource<TResult> tcs,             IAsyncResult ar,             Func<IAsyncResult, TResult> endMethod)         {             try             {                 tcs.SetResult(endMethod(ar));             }             catch (FaultException fex)             {                 Exception ex = EnsureException(fex);                 tcs.SetException(ex);             }             catch (Exception ex)             {                 tcs.SetException(ex);             }         }         //---------------------------------------------------------------------         private static Exception EnsureException(FaultException fex)         {             Type exType = fex.GetType();             object ex = exType.GetProperty("Detail").GetValue(fex, null);             return ex as Exception;         }     } }

Im obigen Beispiel ist die Methodenpaarung Server - Client so, dass nur synchron-synchron od. nur asynchron-asynchron gearbeitet werden kann. Dieses Verhalten kann geändert werden, siehe eingangs erwähnte Kombinationen, indem die im OperationContract mit der Action- und ReplyAction-Eigenschaft die jeweilige Adresse für die Methode angegeben wird. Dies kann sowohl beim Client als auch beim Server erfolgen. Aber dies ist mMn eher ein Sonderfall.


mfG Gü

Hallo gfoidl,

was mir beim Arbeiten mit dem Proxy noch aufgefallen ist:
Die Methoden für Open() und Close() fehlen beim Proxy komplett => Wenn das Programm lange läuft und der Timeout für den Proxy abgelaufen ist, dann bekomm ich ne TimeOutException. Kann ich die Methoden noch irgendwie "einbauen" oder wie machst du das?

Alles klar, das ist auch wahrscheinlich das sauberste und wenn die wichtigsten Dinge eh gecached werden ist das auch kein Problem (außer bissl Umbauarbeit für mich).

Bei mir sieht das dann folgendermaßen aus:

C#-Code:

using (XXXServiceClient customerService = new XXXServiceClient("NetTcpBinding_IXXService"))                         {                             ...                         }

Hast du noch eine Idee wie ich mir das mit dem Bindingnamen vereinfachen könnte? Sonst muss ich das an jeder Stelle der Verwendung übergeben.

Vielen vielen Dank!

Hmm dann brauch ich aber für jeden Proxy auch eine angepasste ProxyFactory ? :(