Использование асинхронной функции синхронно

static async Task<int> MethodAsync(int arg)
{
    await Task.Delay(2500);
    return arg + 13;
}

int res = Task.Run(() => MethodAsync(10)).GetAwaiter().GetResult();

static TResult RunSync<TResult>(Func<Task<TResult>> func)
{
    TaskFactory _myTaskFactory = new 
          TaskFactory(CancellationToken.None, TaskCreationOptions.None, 
          TaskContinuationOptions.None, TaskScheduler.Default);
 
    CultureInfo cultureUi = CultureInfo.CurrentUICulture;
    CultureInfo culture = CultureInfo.CurrentCulture;
 
    return AsyncHelper._myTaskFactory.StartNew<Task<TResult>>(delegate
    {
        Thread.CurrentThread.CurrentCulture = culture;
        Thread.CurrentThread.CurrentUICulture = cultureUi;
        return func();
    }).Unwrap<TResult>().GetAwaiter().GetResult();
}

static Result InvokeAsyncFuncSynchronously<TResult>(Func< Task<TResult>> func)
{
        TResult result = default(TResult);
        var autoResetEvent = new AutoResetEvent(false);
 
        Task.Run(async () =>
        {
            try
            {
                result = await func();
            }
            catch (Exception exc)
            {
                mErrorLogger.LogError(exc.ToString());
            }
            finally
            {
                autoResetEvent.Set();
            }
        });
        autoResetEvent.WaitOne();
 
        return result;
}

int res = Task.Run(() => MethodAsync(10)).Result;

 private sealed class SingleThreadSynchronizationContext : SynchronizationContext
        {
            /// <summary>The queue of work items.</summary>
            private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> m_queue =
                new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
            /// <summary>The processing thread.</summary>
            private readonly Thread m_thread = Thread.CurrentThread;
            /// <summary>The number of outstanding operations.</summary>
            private int m_operationCount = 0;
            /// <summary>Whether to track operations m_operationCount.</summary>
            private readonly bool m_trackOperations;
 
            /// <summary>Initializes the context.</summary>
            /// <param name="trackOperations">Whether to track operation count.</param>
            internal SingleThreadSynchronizationContext(bool trackOperations)
            {
                m_trackOperations = trackOperations;
            }
 
            /// <summary>Dispatches an asynchronous message to the synchronization context.</summary>
            /// <param name="d">The System.Threading.SendOrPostCallback delegate to call.</param>
            /// <param name="state">The object passed to the delegate.</param>
            public override void Post(SendOrPostCallback d, object state)
            {
                if (d == null) throw new ArgumentNullException("d");
                m_queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
            }
 
            /// <summary>Not supported.</summary>
            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("Synchronously sending is not supported.");
            }
 
            /// <summary>Runs an loop to process all queued work items.</summary>
            public void RunOnCurrentThread()
            {
                foreach (var workItem in m_queue.GetConsumingEnumerable())
                    workItem.Key(workItem.Value);
            }
 
            /// <summary>Notifies the context that no more work will arrive.</summary>
            public void Complete() { m_queue.CompleteAdding(); }
 
            /// <summary>Invoked when an async operation is started.</summary>
            public override void OperationStarted()
            {
                if (m_trackOperations)
                    Interlocked.Increment(ref m_operationCount);
            }
 
            /// <summary>Invoked when an async operation is completed.</summary>
            public override void OperationCompleted()
            {
                if (m_trackOperations &&
                    Interlocked.Decrement(ref m_operationCount) == 0)
                    Complete();
            }
        }
 
 public static TResult ReturnFromAsync<TResult>(this Task<TResult> task)
        {
            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);
 
                task.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);
 
                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                return task.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

int y = MethodAsync(10).ReturnFromAsync();

oldList.ForEach(x => 
{
     User user = new User
     {
          Name = x.Name,
          LastName = x.LastName,         
          Data = Task.Run(() => GetUserDataAsync(x.id)).Result
     };
 
     users.Add(user);
});