Synnefo » Pithos MS Client

        //The Task Iterator style allows the execution of a sequence of patterns using

        //iterator syntax.

        //This particular variation returns the result of the last task, if there is one

        public static Task<TResult> Iterate<TResult>(IEnumerable<Task> asyncIterator)

        {

            if (asyncIterator == null) 

                throw new ArgumentNullException("asyncIterator");

            var enumerator = asyncIterator.GetEnumerator();

            if (enumerator == null)

                throw new InvalidOperationException("Invalid enumerable - GetEnumerator returned null");

            var tcs = new TaskCompletionSource<TResult>();

            tcs.Task.ContinueWith(_ => enumerator.Dispose(), TaskContinuationOptions.ExecuteSynchronously);

            Action<Task> recursiveBody = null;

            recursiveBody = delegate

            {

                try

                {

                    if (enumerator.MoveNext())

                        enumerator.Current.ContinueWith(recursiveBody,

                                                        TaskContinuationOptions.ExecuteSynchronously);

                    else

                    {

                        var lastTask = enumerator.Current as Task<TResult>;

                        var result = (lastTask !=null ) 

                            ? lastTask.Result

                            : default(TResult);

                        tcs.TrySetResult(result);

                    }

                }

                catch (Exception exc)

                {

                    tcs.TrySetException(exc);

                }

            };

            recursiveBody(null);

            return tcs.Task;

        }

        /*  public static byte[] CalculateTopHash(IEnumerable<byte[]> hashMap, string algorithm)

        {

            if (hashMap == null)

                throw new ArgumentNullException("hashMap");

            if (String.IsNullOrWhiteSpace(algorithm))

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

            var hashCount = hashMap.Count();

            if (hashCount == 0)

                return null;

            using (var hasher = HashAlgorithm.Create(algorithm))

            {

                var i = 0;

                var count = hashCount;

                foreach (var block in hashMap)

                {

                    if (i++ != count - 1)

                        hasher.TransformBlock(block, 0, block.Length, null, 0);

                    else

                        hasher.TransformFinalBlock(block, 0, block.Length);

                }

                var finalHash = hasher.Hash;

                return finalHash;

            }

        }*/