This is a helper class to convert Begin-/End- Async pattern method to Tasks and use feature of the new .NET FX functions

AsyncTaskConverter

    public static class AsyncTaskConverter
    {
        public static Task FromAsync<TParameter>(Func<TParameter, AsyncCallback, object, IAsyncResult> beginMethod, Action<IAsyncResult> endMethod, TParameter parameter, object state)
        {
            if (beginMethod == null)
                throw new ArgumentNullException("beginMethod");
            if (endMethod == null)
                throw new ArgumentNullException("endMethod");

            var tcs = new TaskCompletionSource<bool>();

            try
            {
                beginMethod(parameter, (iar) =>
                {
                    try
                    {
                        endMethod(iar);
                        tcs.TrySetResult(true);
                    }
                    catch (OperationCanceledException ex)
                    {
                        tcs.TrySetCanceled();
                        tcs.TrySetResult(false);
                    }
                    catch (Exception ex)
                    {
                        tcs.TrySetException(ex);
                        tcs.TrySetResult(false);
                    }
                }, state);
            }
            catch
            {
                tcs.TrySetResult(false);
                throw;
            }

            return tcs.Task;
        }

        public static Task<TResult> FromAsync<TResult>(Func<AsyncCallback, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, IList<Type> skipExceptions = null)
        {
            if (beginMethod == null)
                throw new ArgumentNullException("beginMethod");
            if (endMethod == null)
                throw new ArgumentNullException("endMethod");

            var tcs = new TaskCompletionSource<TResult>();

            try
            {
                beginMethod((iar) =>
                {
                    try
                    {
                        var result = endMethod(iar);
                        tcs.TrySetResult(result);
                    }
                    catch (OperationCanceledException ex)
                    {
                        tcs.TrySetCanceled();
                    }
                    catch (Exception ex)
                    {
                        if (skipExceptions == null || skipExceptions.Count == 0)
                            tcs.TrySetException(ex);
                        else
                        {
                            Type exType = ex.GetType();
                            for (int i = 0; i < skipExceptions.Count; i++)
                            {
                                if (skipExceptions[i].IsAssignableFrom(exType))
                                {
                                    tcs.TrySetResult(default(TResult));
                                    break;
                                }
                            }
                        }
                    }
                });
            }
            catch
            {
                tcs.TrySetResult(default(TResult));
                throw;
            }

            return tcs.Task;
        }
        public static Task<TResult> FromAsync<P1, TResult>(Func<P1, AsyncCallback, object, IAsyncResult> beginMethod, Func<IAsyncResult, TResult> endMethod, P1 arg, object state, IList<Type> skipExceptions = null)
        {
            if (beginMethod == null)
                throw new ArgumentNullException("beginMethod");
            if (endMethod == null)
                throw new ArgumentNullException("endMethod");

            var tcs = new TaskCompletionSource<TResult>();

            try
            {
                //Bis auf begin ist alles gleich
                //kann man das vereinheitlichen?

                beginMethod(arg, (iar) =>
                {
                    try
                    {
                        var result = endMethod(iar);
                        tcs.TrySetResult(result);
                    }
                    catch (OperationCanceledException ex)
                    {
                        tcs.TrySetCanceled();
                    }
                    catch (Exception ex)
                    {
                        if (skipExceptions == null || skipExceptions.Count == 0)
                            tcs.TrySetException(ex);
                        else
                        {
                            Type exType = ex.GetType();
                            for (int i = 0; i < skipExceptions.Count; i++)
                            {
                                if (skipExceptions[i].IsAssignableFrom(exType))
                                {
                                    tcs.TrySetResult(default(TResult));
                                    break;
                                }
                            }
                        }
                    }
                }, state);
            }
            catch
            {
                tcs.TrySetResult(default(TResult));
                throw;
            }

            return tcs.Task;
        }

    }