C# ICollection.ElementAt方法代码示例

    public override TypingStatus ProcessNewFrame(Point3D cursor, ICollection<TypingGesture> gestures, Microsoft.Kinect.Skeleton stableSkeleton, double deltaTimeMilliseconds, TypingDexterity dexterity)
    {
      double columnData = cursor.X;
      double rowData = cursor.Y;
      double constraintData = cursor.Z;

      if (cursor.IsFrozen)
      {
        columnData = cursor.FrozenX;
        rowData = cursor.FrozenY;
        constraintData = cursor.FrozenZ;
      }

      if (columnData < 0 || rowData < 0)
        return new TypingStatus();
      double stepX = 1.0 / layoutCols;
      double stepY = 1.0 / layoutRows;

      int col = (int)(columnData / stepX);
      int row = (int)(rowData / stepY);

      TypingStatus status = new TypingStatus();
      status.HighlightedKey = layout[row * layoutCols + col];
      if (gestures != null && gestures.Count > 0 && gestures.ElementAt(0).Type == GestureType.Tap)
      {
        TypingGesture gesture = gestures.ElementAt(0);
        col = (int)(gesture.Position.X / stepX);
        row = (int)(gesture.Position.Y / stepY);
        status.SelectedKey = layout[row * layoutCols + col];
      }

      return status;
    }

        public JsonResult Add(int encounterId, ICollection<int> newTurnOrder, string description)
        {
            // This is because the LINQ can't translate this command, it needs a flat int.
            var actorId = newTurnOrder.First();

            var encounter = context.Encounters.First(e => e.Id.Equals(encounterId));
            var actingCharacter = context.Characters.First(p => p.Id.Equals(actorId));

            var feedEntry = new EncounterFeedEntry
            {
                ActingCharacter = actingCharacter,
                Description = description
            };
            context.Actions.Add(feedEntry);

            encounter.Initiatives.First(p => p.Character.Id.Equals(newTurnOrder.ElementAt(0)))
                .TurnOrder = newTurnOrder.Count()-1;

            for(var i=1; i<newTurnOrder.Count(); ++i)
            {
                encounter.Initiatives.First(p => p.Character.Id.Equals(newTurnOrder.ElementAt(i)))
                    .TurnOrder = i-1;
            }

            encounter.FeedEntries.Add(feedEntry);
            context.SaveChanges();

            return Json("Successfully posted");
        }

        public static ReportRow Unify(ICollection<ReportRow> reportRows)
        {
            if (reportRows == null || reportRows.Count == 0)
            {
                throw new ArgumentException("reportRows");
            }

            var newRow = new ReportRow
            {
                Name = reportRows.First().Name,
                MaxValue = reportRows.First().MaxValue,
                Results = new List<int>()
            };

            for (var i = 0; i < reportRows.Count; i++)
            {
                if (newRow.Name != reportRows.ElementAt(i).Name)
                {
                    throw new Exception("Rows discrepancy");
                }

                newRow.Results.AddRange(reportRows.ElementAt(i).Results);
            }

            return newRow;
        }

        public ICollection<IGestureEvent> DetectGesture(ICollection<ITouch> touches)
        {
            List<IGestureEvent> flicks = new List<IGestureEvent>();
            List<ITouch> usedTouch = new List<ITouch>(touches.Count);

            for (int i = 0; i < touches.Count; i++)
            {
                ITouch touch1 = touches.ElementAt(i);
                for (int j = i + 1; j < touches.Count; j++)
                {
                    ITouch touch2 = touches.ElementAt(j);

                    // Khong su dung lai cac touch da bat
                    if (usedTouch.Contains(touch1) || usedTouch.Contains(touch2))
                        continue;
                    float angle = (float)(GMath.Angle(touch1.Positions.Delta, touch2.Positions.Delta) * 180 / Math.PI); // Degree

                    if (angle < minAngle &&
                        (touch1.SystemTouch.State == TouchLocationState.Released || touch2.SystemTouch.State == TouchLocationState.Released))
                    {

                        flicks.Add(new DoubleFlick(touch1, touch2));
                        usedTouch.Add(touch1);
                        usedTouch.Add(touch2);
                    }
                }
            }

            return null;
        }

        public ICollection<IGestureEvent> DetectGesture(ICollection<ITouch> touches)
        {
            List<IGestureEvent> drags = new List<IGestureEvent>(touches.Count);

            List<ITouch> usedTouch = new List<ITouch>(touches.Count);
            for (int i = 0; i < touches.Count; i++ )
            {
                ITouch touch1 = touches.ElementAt(i);
                for (int j = i + 1; j < touches.Count; j++)
                {
                    ITouch touch2 = touches.ElementAt(j);

                    // Khong su dung lai cac touch da bat
                    if (usedTouch.Contains(touch1) || usedTouch.Contains(touch2))
                        continue;
                    float angle = (float)(GMath.Angle(touch1.Positions.Delta, touch2.Positions.Delta) * 180 / Math.PI); // Degree

                    if (angle < minAngle)
                    {
                        drags.Add(new DoubleDrag(touch1, touch2));
                        usedTouch.Add(touch1);
                        usedTouch.Add(touch2);
                    }
                }
            }

            return drags;
        }

 static bool IsBigger(ICollection<int> arr ,int position)
 {
     if (position <= 0 || position >= arr.Count-1)
     {
         throw new IndexOutOfRangeException("THE NUMBER AT SPECIFIED INDEX DOES NOT HAVE TWO NEIGHBORS OR INDEX IS OUT OF RANGE!");
     }
     return (arr.ElementAt(position) > arr.ElementAt(position - 1) && arr.ElementAt(position) > arr.ElementAt(position + 1));
 }

 private void clearOrder(ICollection<order> orders)
 {
     for (int i = 0; i < orders.Count;i++ )
     {
         orders.ElementAt(i).waiter_id = null;
         orders.ElementAt(i).version = orders.ElementAt(i).version + 1;
         db.Entry(orders.ElementAt(i)).State = EntityState.Modified;
     }
 }

        public static MvcHtmlString CheckBoxList(this HtmlHelper html, string name, ICollection<SelectListItem> list)
        {
            StringBuilder htmlTags = new StringBuilder();

            if (list == null)
            {
                return new MvcHtmlString("");
            }

            for (int i = 0; i < list.Count; i++)
            {
                TagBuilder hiddenTextTag = new TagBuilder("input");
                hiddenTextTag.Attributes.Add(new KeyValuePair<string, string>("name", name + "[" + i + "].Text"));
                hiddenTextTag.Attributes.Add(new KeyValuePair<string, string>("value", list.ElementAt<SelectListItem>(i).Text));
                hiddenTextTag.Attributes.Add(new KeyValuePair<string, string>("type", "hidden"));
                htmlTags.Append(hiddenTextTag.ToString());

                TagBuilder hiddenValueTag = new TagBuilder("input");
                hiddenValueTag.Attributes.Add(new KeyValuePair<string, string>("name", name + "[" + i + "].Value"));
                hiddenValueTag.Attributes.Add(new KeyValuePair<string, string>("value", list.ElementAt<SelectListItem>(i).Value));
                hiddenValueTag.Attributes.Add(new KeyValuePair<string, string>("type", "hidden"));
                htmlTags.Append(hiddenValueTag.ToString());

                TagBuilder checkBoxDiv = new TagBuilder("div");
                checkBoxDiv.AddCssClass("checkbox");

                TagBuilder checkBoxlabel = new TagBuilder("label");

                if (list.ElementAt<SelectListItem>(i).Selected)
                {
                    TagBuilder checkedTag = new TagBuilder("input");
                    checkedTag.Attributes.Add(new KeyValuePair<string, string>("name", name + "[" + i + "].Selected"));
                    checkedTag.Attributes.Add(new KeyValuePair<string, string>("value", "true"));
                    checkedTag.Attributes.Add(new KeyValuePair<string, string>("type", "checkbox"));
                    checkedTag.Attributes.Add(new KeyValuePair<string, string>("checked", "checked"));
                    //htmlTags.Append(checkedTag.ToString() + " " + list.ElementAt<SelectListItem>(i).Text);

                    checkBoxlabel.InnerHtml += checkedTag.ToString() + " " + list.ElementAt<SelectListItem>(i).Text;
                    checkBoxDiv.InnerHtml += checkBoxlabel.ToString();
                    htmlTags.Append(checkBoxDiv.ToString());
                }
                else
                {
                    TagBuilder unCheckedTag = new TagBuilder("input");
                    unCheckedTag.Attributes.Add(new KeyValuePair<string, string>("name", name + "[" + i + "].Selected"));
                    unCheckedTag.Attributes.Add(new KeyValuePair<string, string>("value", "true"));
                    unCheckedTag.Attributes.Add(new KeyValuePair<string, string>("type", "checkbox"));
                    //htmlTags.Append(unCheckedTag.ToString() + " " + list.ElementAt<SelectListItem>(i).Text);

                    checkBoxlabel.InnerHtml += unCheckedTag.ToString() + " " + list.ElementAt<SelectListItem>(i).Text;
                    checkBoxDiv.InnerHtml += checkBoxlabel.ToString();
                    htmlTags.Append(checkBoxDiv.ToString());
                }
            }

            return new MvcHtmlString(htmlTags.ToString());
        }

 static int GetIndex(ICollection<int> arr)
 {
     for (int i = 1; i < arr.Count-1; i++)
     {
         if (arr.ElementAt(i) > arr.ElementAt(i - 1) && arr.ElementAt(i) > arr.ElementAt(i + 1))
         {
             return i;
         }
     }
     return -1;
 }

        public static void Call(ICollection<ITerminal> terminals, ICollection<PhoneNumber> PhoneNumbers)
        {
            Random r = new Random();

            var t1 = terminals.ElementAt(r.Next(0, terminals.Count ));
            var t2 = terminals.ElementAt(r.Next(0, terminals.Count));
            t1.Call(t2.PhoneNumber);
            t2.Answer();
            Thread.Sleep(500);
            t1.Reset();
        }

 static int GetMax(int start, ICollection<int> arr)
 {
     int result = int.MinValue;
     for (int i = start; i < arr.Count; i++)
     {
         if (result < arr.ElementAt(i))
         {
             result = arr.ElementAt(i);
         }
     }
     return result;
 }

		private static bool MatchesActionArguments(this TRoute route, ICollection<Type> actionArguments)
		{
			if (actionArguments == null)
			{
				return true;
			}

			// When specifying arguments, it must be an action level attribute route with a single action descriptor
			TActionDescriptor actionDescriptor = ((TActionDescriptor[])route.DataTokens[RouteDataTokenKeys.Actions]).Single();

			ICollection<TParameterDescriptor> parameterInfos = actionDescriptor.GetParameters();

			if (parameterInfos.Count() != actionArguments.Count)
			{
				return false;
			}

			for (int i = 0; i < actionArguments.Count; i++)
			{
				if (actionArguments.ElementAt(i) != parameterInfos.ElementAt(i).ParameterType)
				{
					return false;
				}
			}

			return true;
		}

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="elements">Model element to create proto elements for.</param>
        /// <param name="operation">Operation.</param>
        public ModelProtoGroup(ICollection<ModelElement> elements, ModelProtoGroupOperation operation)
        {
            if (elements.Count == 0)
                throw new ArgumentNullException("elements");

            this.protoElements = new List<ModelProtoElement>(6000);
            this.protoRootElements = new List<ModelProtoElement>(6000);

            this.protoEmbeddingLinks = new List<ModelProtoLink>(6000);
            this.protoReferenceLinks = new List<ModelProtoLink>(6000);

            this.protoOperation = operation;

            foreach (ModelElement modelElement in elements)
            {
                if (modelElement is IModelMergeElements)
                {
                    ModelProtoElement root;
                    if( operation == ModelProtoGroupOperation.Copy )
                        root = (modelElement as IModelMergeElements).ModelCreateMergeCopy(this);
                    else
                        root = (modelElement as IModelMergeElements).ModelCreateMoveCopy(this);
                    if (root == null)
                        throw new ArgumentNullException("root");
                    this.protoRootElements.Insert(0, root);
                }
            }

            InitDictionaries(elements.ElementAt(0).Partition);
        }

 public ICollection<Film> recommend(ICollection<Film> precondition, ICollection<Film> yetRecommended, int Number)
 {
     if(precondition==null|| precondition.Count<1)
         return new List<Film>();
     var retList = new List<Film>();
     for (int i = 0; i < (Number>0?Number:10); i++)
     {
         var tmp_film = precondition.ElementAt(new Random().Next(0, precondition.Count()-1));
         if(tmp_film.actors!=null&&tmp_film.actors.Count()>0)
         {
             var tmp_actor = tmp_film.actors.ElementAt(new Random().Next(0, tmp_film.actors.Count()-1));
             if (tmp_actor != null)
             {
                 tmp_actor = actorsservice.getActorWithFilmsFromDAL(tmp_actor.ID);
                 if (tmp_actor != null&&tmp_actor.films.Count()>0)
                 {
                     var rec_film = tmp_actor.films.ElementAt(new Random().Next(0, tmp_actor.films.Count() - 1));
                     if (!yetRecommended.Contains(rec_film) && !retList.Contains(rec_film))
                         retList.Add(rec_film);
                 }
             }
         }
     }
     return retList;
 }

 public DataTable GetDBValues(ICollection<PactControlData> _controlData)
 {
     DataTable DbValues = BuildDBColumns(_controlData);
     DbValues.TableName = "UIVALUES";
     PactControlData objPactCtrl;
     PactTextBoxData objPactTB;
     PactComboBoxData objPactCmb;
     PactCheckBoxData objPactChk;
     PactDatePickerData objPactDp;
     DataRow dr = DbValues.NewRow();
     if (_controlData != null && _controlData.Count > 0)
     {
         for (int i = 0; i < _controlData.Count; i++)
         {
             objPactCtrl = _controlData.ElementAt<PactControlData>(i);
             if (objPactCtrl.GetType().Name.ToString().Equals("PactTextBoxData"))
             {
                 objPactTB = (PactTextBoxData)objPactCtrl;
                 if (objPactTB.DBColumnName != null)
                 {
                     if (objPactTB.Text != null)
                     {
                         dr[objPactTB.DBColumnName.Trim()] = objPactTB.Text.Trim();
                     }
                 }
             }
             else if (objPactCtrl.GetType().Name.ToString().Equals("PactComboBoxData"))
             {
                 objPactCmb = (PactComboBoxData)objPactCtrl;
                 if (objPactCmb.DBColumnName != null)
                 {
                     if (objPactCmb.SelectedValue != null)
                     {
                         dr[objPactCmb.DBColumnName.Trim()] = objPactCmb.SelectedValue.Trim();
                     }
                 }
             }
             else if (objPactCtrl.GetType().Name.ToString().Equals("PactCheckBoxData"))
             {
                 objPactChk = (PactCheckBoxData)objPactCtrl;
                 if (objPactChk.DBColumnName != null)
                 {
                     dr[objPactChk.DBColumnName.Trim()] = objPactChk.IsChecked;
                 }
             }
             else if (objPactCtrl.GetType().Name.ToString().Equals("PactDatePickerData"))
             {
                 objPactDp = (PactDatePickerData)objPactCtrl;
                 if (objPactDp.DBColumnName != null)
                 {
                     dr[objPactDp.DBColumnName.Trim()] = objPactDp.Date;
                 }
             }
         }
     }
     DbValues.Rows.Add(dr);
     return DbValues;
 }