C# SortedList.SelectMany方法代码示例

        public void RunSuite(Spec suite)
        {
            var mainSuiteExecutionPlan = new SortedList<string, List<Definition>>();
           // var mainSuiteExecutionPlan = new Dictionary<string, List<Definition>>();
            foreach (var spec in suite.Registry.ExecutableLookupTable)
            {
                mainSuiteExecutionPlan.Add(spec.Id, new List<Definition>());
                List<Definition> executionPlan = mainSuiteExecutionPlan[spec.Id];
                executionPlan.Add(spec);
                AddBeforeEachs(spec, executionPlan);              
                AddAfterEach(spec, executionPlan);
            }

            foreach (var executionPlan in mainSuiteExecutionPlan)
            {
                foreach (var definition in executionPlan.Value)
                {
                    if(definition.GetType() == typeof(GlobalHook))
                    {
                        var globalHook = (GlobalHook) definition;
                        if (globalHook.Kind == GlobalHookKind.BeforeAll)
                        {
                            if (globalHook.ExecutionStatus != ExecStatus.NotRun)
                                continue;
                        }

                        if (globalHook.Kind == GlobalHookKind.AfterAll)
                        {
                            var max = mainSuiteExecutionPlan.SelectMany(x => x.Value, (x, y) => new
                            {
                                x.Key,
                                val=y,
                                idx=mainSuiteExecutionPlan.IndexOfKey(x.Key)
                            })
                            .Where(x=>x.val==definition)
                            .Max(x=>x.idx);
                            var index = mainSuiteExecutionPlan.IndexOfKey(executionPlan.Key);
                            if (index<max)
                            {
                                continue;
                            }
                        }

                    }
                    SafeExecute(definition);
                }
                
            }
        }

		/// <summary>
		/// The whole variables must be the same type.
		/// </summary>
		/// <param name="entities">object id,variable id, variable description</param>
		/// <returns></returns>
		private Return<object> ValidateCharacteristics(SortedList<int, SortedList<int, ICharacteristic>> entities)
		{
			Return<object> _answer = new Return<object>();
			try
			{
				int _minKey = entities.SelectMany(e => e.Value.Select(sl => sl.Key)).Min(k => k)
					, _maxKey = entities.SelectMany(e => e.Value.Select(sl => sl.Key)).Max(k => k);

				for (int _i = _minKey; _i <= _maxKey; _i++)
				{//characteristic to characteristic
					IEnumerable<SortedList<int, ICharacteristic>> _entitiesAll = entities.Select(e => e.Value);
					IEnumerable<SortedList<int, ICharacteristic>> _entitiesWithCharacteristic = _entitiesAll.Where(e => e.ContainsKey(_i));
					if (_entitiesWithCharacteristic.Any())
					{
						IEnumerable<ICharacteristic> _listOfCharacteristic = _entitiesWithCharacteristic.Select(e => e[_i]);
						IEnumerable<IGrouping<Type, ICharacteristic>> _groupByType = _listOfCharacteristic.GroupBy(c => c.GetType());
						if (_groupByType.Count() > 1)
						{
							string _message = string.Format("There are different types in characteristic {1}{0} ", Environment.NewLine, Convert.ToString(_i));
							_answer.theresError = true;
							_answer.error = Utility.GetError(new Exception(_message), this.GetType());
						}
					}

					if (_answer.theresError)
						break;
				}//characteristic to characteristic
			}
			catch (Exception _ex)
			{
				_answer.theresError = true;
				_answer.error = Utility.GetError(_ex, this.GetType());
			}
			return _answer;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="entities">object id,variable id, variable description</param>
		/// <returns></returns>
		private Return<object> FillHoles(SortedList<int, SortedList<int, ICharacteristic>> entities)
		{
			Return<object> _answer = new Return<object>();
			try
			{
				int _minKey = entities.SelectMany(e => e.Value.Select(sl => sl.Key)).Min(k => k)
					, _maxKey = entities.SelectMany(e => e.Value.Select(sl => sl.Key)).Max(k => k);

				for (int _i = _minKey; _i <= _maxKey; _i++)
				{//characteristic to characteristic
					IEnumerable<SortedList<int, ICharacteristic>> _entitiesAll = entities.Select(e => e.Value);
					IEnumerable<SortedList<int, ICharacteristic>> _entitiesWithCharacteristic = _entitiesAll.Where(e => e.ContainsKey(_i));
					IEnumerable<SortedList<int, ICharacteristic>> _entitiesWithoutTheCharacteristic = _entitiesAll.Except(_entitiesWithCharacteristic);

					if (_entitiesWithCharacteristic.Any())
					{
						IEnumerable<ICharacteristic> _listOfCharacteristic = _entitiesWithCharacteristic.SelectMany(o => o.Values);
						ICharacteristic _characteristic = _listOfCharacteristic.First();
						ICharacteristic _filler = _characteristic.FillHole(_listOfCharacteristic);
						foreach (SortedList<int, ICharacteristic> _list in _entitiesWithoutTheCharacteristic)
							_list.Add(_i, _filler.Clone());
					}
				}//characteristic to characteristic
			}
			catch (Exception _ex)
			{
				_answer.theresError = true;
				_answer.error = Utility.GetError(_ex, this.GetType());
			}
			return _answer;
		}