Parallel.ForEach что не верно? Не компилируется

    class Program
    {
        static void Main(string[] args)
        {
            ParallelOptions parOpt = new ParallelOptions();
            SynchronizationContext context = SynchronizationContext.Current;
 
            var localInit = new Func<WebClient>(
                () =>
                {
                    var webClient = new WebClient();
                    webClient.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
                    return webClient;
                });
 
            var body = new Func<UserViewModel, ParallelLoopState, WebClient, ParWebLinkSet>(
                (user, pLoopState, webClient) =>
                {
                    var set = new ParWebLinkSet();
                    set.Bytes = webClient.DownloadData(new Uri(user.PhotoLink));
                    set.User = user;
                    return set;
                });
 
            var localFinally = new Action<ParWebLinkSet>(
                (set) => context.Post(
                    (state) =>
                    {
                        var res = (ParWebLinkSet)state;
                        res.User.Photo = GetBitmapImageFromBytes(res.Bytes);
                    }, set));
 
            ParallelLoopResult loopRes = Parallel.ForEach(Users, parOpt, localInit, body, localFinally);
 
 
            Console.ReadKey();
        }
    }

private void SomeMethod()
{
    SynchronizationContext context = SynchronizationContext.Current;
    var client = new WebClient();
    client.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
    Task.Factory.StartNew(() =>
    {
        foreach (UserViewModel user in Users)
        {
            byte[] bytesBmp = client.DownloadData(new Uri(user.PhotoLink));
            context.Send((state) =>
            {
                var res = (Tuple<UserViewModel, byte[]>)state;
                res.Item1.Photo = GetBitmapImageFromBytes(res.Item2);
            }, new Tuple<UserViewModel, byte[]>(user, bytesBmp));
        }
    }).ContinueWith((task) => client.Dispose());
}

private void SomeMethod()
{
    SynchronizationContext context = SynchronizationContext.Current;
 
    int counter = 0;
    Parallel.ForEach(Users,
        (user, pLoopState) =>
        {
            var webClient = new WebClient();
            webClient.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
 
            byte[] bytesBmp = webClient.DownloadData(new Uri(user.PhotoLink));
            context.Post((state) =>
            {
                var res = (Tuple<UserViewModel, byte[]>)state;
                res.Item1.Photo = GetBitmapImageFromBytes(res.Item2);
            }, new Tuple<UserViewModel, byte[]>(user, bytesBmp));
            Debug.WriteLine("{0}) {1}", Interlocked.Increment(ref counter), user.FullName);
        });
}

        public void InitializeData()
        {
            User loginedUser = _vkApi.Users.Get(_vkApi.UserId, ProfileFields.All);
            List<User> friends = _vkApi.Friends.Get(_vkApi.UserId,
                ProfileFields.FirstName | ProfileFields.LastSeen | ProfileFields.Photo100);
 
            LoginedUser = new UserViewModel(loginedUser, friends.Count);
 
            foreach (User person in friends)
            {
                var user = new UserViewModel(person);
                Users.Add(user);
            }
 
            DownloadImages(Users);
        }
 
        private void DownloadImages(IList<UserViewModel> users)
        {
            SynchronizationContext context = SynchronizationContext.Current;
            var photos = new BlockingCollection<Tuple<UserViewModel, BitmapImage>>(users.Count);
 
            Task.Factory.StartNew(() =>
                  {
 
                      var loopRes = Parallel.ForEach(Users,
                            (user, pLoopState) =>
                            {
                                byte[] bytesBmp;
                                using (var webClient = new WebClient())
                                {
                                    webClient.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
                                    bytesBmp = webClient.DownloadData(new Uri(user.PhotoLink));
                                }
                                context.Post((state) =>
                                {
                                    var res = (Tuple<UserViewModel, byte[]>)state;
                                    photos.Add(new Tuple<UserViewModel, BitmapImage>(res.Item1,
                                        GetBitmapImageFromBytes(res.Item2)));
                                }, new Tuple<UserViewModel, byte[]>(user, bytesBmp));
                            });
 
                      while (!loopRes.IsCompleted)
                      {
                          Thread.Sleep(10);
                      }
 
                      return photos;
                  }).ContinueWith(task =>
                  {
                      foreach (Tuple<UserViewModel, BitmapImage> res in task.Result)
                      {
                          res.Item1.Photo = res.Item2;
                      }
                  });
        }

private void DownloadImages(IList<UserViewModel> users)
{
    SynchronizationContext context = SynchronizationContext.Current;
 
    Task.Factory.StartNew(() =>
        {
            var loopRes = Parallel.ForEach(Users,
                (user, pLoopState) =>
                {
                    byte[] bytesBmp;
                    using (var webClient = new WebClient())
                    {
                        webClient.CachePolicy =
                            new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
                        bytesBmp = webClient.DownloadData(new Uri(user.PhotoLink));
                    }
                    context.Post((state) =>
                        {
                            var res = (Tuple<UserViewModel, byte[]>)state;
 
                            var tuple =
                                new Tuple<UserViewModel, BitmapImage>(res.Item1,
                                    GetBitmapImageFromBytes(res.Item2));
 
                            tuple.Item1.Photo = tuple.Item2;
 
                        }, new Tuple<UserViewModel, byte[]>(user, bytesBmp));
 
                });
            while (!loopRes.IsCompleted)
            {
                Thread.Sleep(10);
            }
        });
}

while (!loopRes.IsCompleted)
{
    Thread.Sleep(10);
}

private void DownloadImages(IEnumerable<UserViewModel> users)
{
    SynchronizationContext context = SynchronizationContext.Current;
 
    Task.Factory.StartNew(() =>
        {
            Parallel.ForEach(users,
                (user, pLoopState) =>
                {
                    byte[] bytesBmp;
                    using (var webClient = new WebClient())
                    {
                        webClient.CachePolicy =
                            new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
                        bytesBmp = webClient.DownloadData(new Uri(user.PhotoLink));
                    }
                    context.Post((state) =>
                        {
                            var res = (Tuple<UserViewModel, byte[]>)state;
                            res.Item1.Photo = GetBitmapImageFromBytes(res.Item2);
                        }, new Tuple<UserViewModel, byte[]>(user, bytesBmp));
 
                });
        });
}

Parallel.ForEach(users, u => picturebox1.Image = GetPicture(u));

Parallel.ForEach(users, u => Dispatcher.Invoke(()=>picturebox1.Image = GetPicture(u)));