C# Task.Concat方法代码示例

		public async Task Should_Work_For_Multiple_Types()
		{
			/* Setup */
			using (var requester = TestClientFactory.CreateNormal())
			using (var responder = TestClientFactory.CreateNormal())
			{
				const int numberOfCalls = 10000;
				var firstResponseTasks = new Task[numberOfCalls];
				var secondResponseTasks = new Task[numberOfCalls];
				responder.RespondAsync<FirstRequest, FirstResponse>((req, i) =>
					Task.FromResult(new FirstResponse { Infered = Guid.NewGuid() }));
				responder.RespondAsync<SecondRequest, SecondResponse>((request, context) =>
					Task.FromResult(new SecondResponse { Source = Guid.NewGuid() }));

				/* Test */
				for (var i = 0; i < numberOfCalls; i++)
				{
					var firstResponse = requester.RequestAsync<FirstRequest, FirstResponse>();
					var secondResponse = requester.RequestAsync<SecondRequest, SecondResponse>();
					firstResponseTasks[i] = firstResponse;
					secondResponseTasks[i] = secondResponse;
				}
				Task.WaitAll(firstResponseTasks.Concat(secondResponseTasks).ToArray());
				var firstIds = firstResponseTasks
					.OfType<Task<FirstResponse>>()
					.Select(b => b.Result.Infered)
					.Where(id => id != Guid.Empty)
					.Distinct()
					.ToList();
				var secondIds = secondResponseTasks
					.OfType<Task<SecondResponse>>()
					.Select(b => b.Result.Source)
					.Where(id => id != Guid.Empty)
					.Distinct()
					.ToList();
				/* Assert */
				Assert.Equal(expected: numberOfCalls, actual: firstIds.Count);
				Assert.Equal(expected: numberOfCalls, actual: secondIds.Count);
			}
		}

        //TODO
        public static async Task Create(Task[] tasks, IDataflowBlock[] dataFlowBlocks)
        {
            var pipelineTasks = tasks.Concat(dataFlowBlocks.Select(x => x.Completion)).ToArray();

            var catchTasks = new Task[pipelineTasks.Length];
            for (var i = 0; i < pipelineTasks.Length; i++)
            {
                var task = pipelineTasks[i];

                catchTasks[i] =
                    task.ContinueWith(_ =>
                    {
                        if (task.IsFaulted)
                        {
                            // fault all dataflow blocks as soon as any fault occurs
                            foreach (var dataFlowBlock in dataFlowBlocks)
                                dataFlowBlock.Fault(task.Exception);
                        }
                    });
            }

            try
            {
                var allTasks = pipelineTasks.Concat(catchTasks).ToArray();
                await Task.WhenAll(allTasks);

                // we should only be here if all tasks completed successfully
                Debug.Assert(allTasks.All(x => x.Status == TaskStatus.RanToCompletion));
            }
            catch (Exception ex)
            {
                // ensure all dataflow blocks are faulted
                foreach (var dataFlowBlock in dataFlowBlocks)
                    dataFlowBlock.Fault(ex);

                throw;
            }
        }

      public void Parallel_PutGetDelete_Random()
      {
        const int PUTTER_CNT  = 2, PUTTER_OP_CNT  = 2 * 10000;
        const int GETTER_CNT  = 6, GETTER_OP_CNT  = 2 * 30000;
        const int DELETER_CNT = 2, DELETER_OP_CNT = 2 * 10000;

        var data = new ConcurrentDictionary<PilePointer, string>();

        var getAccessViolations = new ConcurrentDictionary<int, int>();
        var deleteAccessViolations = new ConcurrentDictionary<int, int>();

        using (var pile = new DefaultPile())
        {
          pile.Start();

          var ipile = pile as IPile;

          // putter tasks
          var putters = new Task[PUTTER_CNT];
          for (int it = 0; it < PUTTER_CNT; it++)
          {
            var task = new Task(() => {

              for (int i = 0; i < PUTTER_OP_CNT; i++)
              {
                var str = NFX.Parsing.NaturalTextGenerator.Generate();
                var pp = ipile.Put(str);
                data.TryAdd(pp, str);
              }

            });

            putters[it] = task;
          }

          // getter tasks
          var getters = new Task[GETTER_CNT];
          for (int it = 0; it < GETTER_CNT; it++)
          {
            var task = new Task(() => {

              for (int i = 0; i < GETTER_OP_CNT; i++)
              {
                if (data.Count == 0) {
                  System.Threading.Thread.Yield();
                  continue;
                }
                var idx = ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, data.Count-1);
                var kvp = data.ElementAt(idx);
                try
                {
                  
                  var str = ipile.Get(kvp.Key);
                  Assert.AreEqual(str, kvp.Value);
                }
                catch (PileAccessViolationException)
                {
                  getAccessViolations.AddOrUpdate(System.Threading.Thread.CurrentThread.ManagedThreadId, 1, (mid, val) => val + 1);
                }
              }
            });
            getters[it] = task;
          }

          // deleter tasks
          var deleters = new Task[DELETER_CNT];
          for (int it = 0; it < DELETER_CNT; it++)
          {
            var task = new Task(() => {

              for (int i = 0; i < DELETER_OP_CNT; i++)
              {
                if (data.Count == 0) {
                  System.Threading.Thread.Yield();
                  continue;
                }
                var idx = ExternalRandomGenerator.Instance.NextScaledRandomInteger(0, data.Count-1);
                var kvp = data.ElementAt(idx);
                try
                {
                  ipile.Delete(kvp.Key);
                }
                catch (PileAccessViolationException)
                {
                  deleteAccessViolations.AddOrUpdate(System.Threading.Thread.CurrentThread.ManagedThreadId, 1, (mid, val) => val + 1);
                }
              }
            });
            deleters[it] = task;
          }


          foreach (var task in putters) task.Start();
          foreach (var task in getters) task.Start();
          foreach (var task in deleters) task.Start();


          Task.WaitAll(putters.Concat(getters).Concat(deleters).ToArray());

          foreach (var kvp in getAccessViolations)
//.........这里部分代码省略.........

        public IEnumerable<BondSpreadMergedResult> ComputeBondSpread(string ccy, string oisCurveName, string liborCurveName)
        {
            try
            {
                var nowTime = DateTime.Now;
                Log.Info("Prepare for bond spread computation...");


                if (futureBuilder.Today.Date < DateTime.UtcNow.AddHours(-5).Date)
                {
                    Log.InfoFormat("previous today date set to {0}, now today date is set to {1}", futureBuilder.Today.Date, DateTime.UtcNow.AddHours(-5).Date);
                    // when we move forward to the next day, we need to roll dates
                    futureBuilder.ComputeRelevantDatesForForwards();
                    futureBuilder.ComputeRollDates();     
               
                    // recompute closes
                    histPriceCache.Clear();
                    futureEnricher.ClearCloseCache();
                }

                // 1. need to get all bonds statics
                //var bondLists = GetBondStatics();
                //var allbonds = bondSpreadServiceModel.GetAllSecurities("T", "Term", DateTime.Today.AddDays(30));
                //var bondLists = bondPriceCache.Keys.ToArray();
                var bondLists = bondStaticCache.Keys.ToArray();

                // 2. build curve                
                curves.SetupCurves(ccy, oisCurveName, liborCurveName);
                Log.InfoFormat("Finished curve bulding in {0}secs", (DateTime.Now - nowTime).TotalSeconds);

                // 3. compute bond spread
                string country = "US";
                BondAnalytics.Country eCountry;
                BondAnalytics.CountryMappings.TryGetValue(country.ToUpper().Trim(), out eCountry);
                
                long Freq = 6; // hard code to be semi-annual?

                // all the bond prices            
                double optStartDate = 0;
                double optFirstCpnDate = 0;

                Log.Info("Computing bond spread...");
                BondSpreadResult[] liveBondSpreads = null;
                BondSpreadResult[] closeBondSpreads = null;
                BondSpreadResult[] futureSpreadsLive = null;
                BondSpreadResult[] futureSpreadsClose = null;

                IEnumerable<BondSpreadMergedResult> MergedBondSpreads = null;
                IEnumerable<BondSpreadMergedResult> MergedFuturesSpreads = null;

                DateTime futureStart = DateTime.Now;
                // future enrichment
                lock(lockobj)
                { 
                    foreach (var future in FutureCache)
                    {
                        try
                        {
                            futureEnricher.EnrichFuture(future, curves.GetLiveOISCurve(), curves.GetLiveLiborCurve(),  curves.GetCloseOISCurve(), curves.GetCloseLiborCurve(), this); // oiscurve, liborcurve    
                        }
                        catch (Exception e)
                        {                        
                            Log.Error(string.Format("Failed to enrich future {0}", future.Contract), e);
                            future.CanComputeSpread = false;
                        }
                    
                    }
                }
                Log.InfoFormat("Finished future enrichment in {0}secs", (DateTime.Now - futureStart).TotalSeconds);

                try
                {
                    // compute bond prices in parallel
                    var starttime = DateTime.Now;
                    var computingbondlist = bondLists.ToArray();
                    var closecomputeTasks = new Task<BondSpreadResult>[computingbondlist.Length];
                    var livecomputeTasks = new Task<BondSpreadResult>[computingbondlist.Length];

                    
                    //var liveBondSpreads = new List<BondSpreadResult>();                    
                               
                    for (int i = 0; i<computingbondlist.Length; i++)
                    {
                        var i1 = i;
                        livecomputeTasks[i] = Task<BondSpreadResult>.Factory.StartNew(
                                () =>
                                    ComputeLiveBondSpreadResult(computingbondlist[i1], eCountry, optStartDate, optFirstCpnDate, Freq, curves.GetLiveLiborCurve(), curves.GetLiveOISCurve()))
                                    .ContinueWith(r => r.Result);
                    }
                    for (int i = 0; i < computingbondlist.Length; i++)
                    {
                        var i1 = i;
                        closecomputeTasks[i] = Task<BondSpreadResult>.Factory.StartNew(
                                () =>
                                     ComputeCloseBondSpreadResult(computingbondlist[i1], eCountry, optStartDate, optFirstCpnDate, Freq, curves.GetCloseLiborCurve(), curves.GetCloseOISCurve()))
                                    .ContinueWith(r => r.Result);
                    }

                    Task.WaitAll(closecomputeTasks.Concat(livecomputeTasks).Cast<Task>().ToArray());                    
                    liveBondSpreads = livecomputeTasks.Select(l => l.Result).Where(r=> r != null).ToArray();
//.........这里部分代码省略.........

        private static void ConnectToNodes(TextWriter log, string tieBreakerKey, int syncTimeout, int keepAlive, bool allowAdmin, string clientName, string[] arr, List<RedisConnection> connections, out Task<string>[] infos, out Task<string>[] aux, AuxMode mode)
        {
            TraceWriteTime("Infos");
            infos = new Task<string>[arr.Length];
            aux = new Task<string>[arr.Length];
            var opens = new Task[arr.Length];
            for (int i = 0; i < arr.Length; i++)
            {
                var option = arr[i];
                if (string.IsNullOrWhiteSpace(option)) continue;

                RedisConnection conn = null;
                try
                {

                    var parts = option.Split(':');
                    if (parts.Length == 0) continue;

                    string host = parts[0].Trim();
                    int port = 6379, tmp;
                    if (parts.Length > 1 && int.TryParse(parts[1].Trim(), out tmp)) port = tmp;
                    conn = new RedisConnection(host, port, syncTimeout: syncTimeout, allowAdmin: allowAdmin);
                    conn.Name = clientName;
                    log.WriteLine("Opening connection to {0}:{1}...", host, port);
                    if (keepAlive >= 0) conn.SetKeepAlive(keepAlive);
                    opens[i] = conn.Open();
                    var info = conn.GetInfoImpl(null, false, false);
                    connections.Add(conn);
                    infos[i] = info;
                    switch (mode)
                    {
                        case AuxMode.TieBreakers:
                            if (tieBreakerKey != null)
                            {
                                aux[i] = conn.Strings.GetString(0, tieBreakerKey);
                            }
                            break;
                        case AuxMode.ClusterNodes:
                            aux[i] = conn.Cluster.GetNodes();
                            break;
                    }

                }
                catch (Exception ex)
                {
                    if (conn == null)
                    {
                        log.WriteLine("Error parsing option \"{0}\": {1}", option, ex.Message);
                    }
                    else
                    {
                        log.WriteLine("Error connecting: {0}", ex.Message);
                    }
                }
            }

            TraceWriteTime("Wait for infos");
            RedisConnectionBase.Trace("select-create", "wait...");
            var watch = new Stopwatch();
            foreach (Task task in infos.Concat(aux).Concat(opens))
            {
                if (task != null)
                {
                    try
                    {
                        int remaining = unchecked((int)(syncTimeout - watch.ElapsedMilliseconds));
                        if (remaining > 0) task.Wait(remaining);
                    }
                    catch { }
                }
            }
            watch.Stop();
            RedisConnectionBase.Trace("select-create", "complete");
        }