C# List.RemoveAt方法代码示例

		//Remove invalid objects from the list. Return true if any were removed.
		private bool ClearInvalidObjects(List<IStText> listToSearch, int offset, bool raiseChangeNotification)
		{
			bool didRemoveAny = false;
			for (int i = listToSearch.Count - 1; i >= 0; i--)
			{
				if (!listToSearch[i].IsValidObject || listToSearch[i].OwnerOfClass(ScrDraftTags.kClassId) != null)
				{
					// Enhance JohnT: if several are removed, especially close together, we might want
					// to combine the change notifications. However I think this will be quite unusual.
					if (m_interestingTests != null)
						m_interestingTests.Remove(listToSearch[i]);
					listToSearch.RemoveAt(i);
					if (raiseChangeNotification)
						RaiseInterestingTextsChanged(i + offset, 0, 1);
					didRemoveAny = true;
				}
			}
			return didRemoveAny;
		}

		protected virtual void EnsureRealSegmentsForNonTrivialAnalyses(List<int> segments, int[] segmentsArray, int iseg, List<int> formsInSegment)
		{
			if (m_cache.IsDummyObject(segmentsArray[iseg]) && HasNonTrivialAnalysis(formsInSegment))
			{
				using (SuppressSubTasks supressActionHandler = new SuppressSubTasks(Cache, true))
				{
					// replace the dummy segment with a real one.
					segmentsArray[iseg] = CmBaseAnnotation.ConvertBaseAnnotationToReal(Cache, segmentsArray[iseg]).Hvo;
					segments.RemoveAt(iseg);
					segments.Insert(iseg, segmentsArray[iseg]);
				}
			}
		}

		/// ------------------------------------------------------------------------------------
		/// <summary>
		/// Removes the invalid characters.
		/// </summary>
		/// <param name="list">The list.</param>
		/// ------------------------------------------------------------------------------------
		private void RemoveInvalidCharacters(List<TextTokenSubstring> list)
		{
			// Getting one cpe and properly disposing it instead of creating a new cpe for every
			// character in the Bible solves TE-8420, plus it is many, many times faster.
			for (int i = list.Count - 1; i >= 0; i--)
			{
				if (!TsStringUtils.IsValidChar(list[i].InventoryText, m_chrPropEng))
					list.RemoveAt(i);
			}
		}

		/// <summary>
		/// Replace SortObjects corresponding to hvoToReplace with new SortObjects for newObj.
		/// </summary>
		/// <param name="newObj"></param>
		/// <param name="hvoToReplace"></param>
		/// <param name="fAssumeSame">if true, we'll try to replace sort objects for hvoToReplace with newObj at the same indices.
		/// if false, we'll rely upon sorter to merge the new item into the right index, or else add to the end.
		/// Enhance: Is there some way we can compare the sort/filter results for newObj and hvoToReplace that is hvo indepedendent?</param>
		/// <returns>resulting list of newSortItems added to SortedObjects</returns>
		protected ArrayList ReplaceListItem(ICmObject newObj, int hvoToReplace, bool fAssumeSame)
		{
			ArrayList newSortItems = new ArrayList();
			// Note: don't check NeedToReloadVirtualProperty here, so we can update the list, even if we need to
			// reload it at a later time. This allows joining/breaking wordforms in the Concordance tools, without
			// necessarily having to reload the entire list. Typically replacements will be with real ids, and those
			// should be stable to add in the new view.
			//if (NeedToReloadVirtualProperty)
			//    return newSortItems;	// we don't need to update the list, if we're planning to reload the whole thing.
			List<int> indicesOfSortItemsToRemove = new List<int>(IndicesOfSortItems(new List<int>(new int[] { hvoToReplace })));
			ArrayList remainingInsertItems = new ArrayList();
			int hvoNewObject = 0;
			if (newObj != null)
			{
				hvoNewObject = newObj.Hvo;
				// we don't want to add new sort items, if we've already added them, but we do want to allow
				// a replacement.
				if (hvoToReplace == hvoNewObject || IndexOfFirstSortItem(new List<int>(new int[] { hvoNewObject })) < 0)
					MakeItemsFor(newSortItems, newObj);
				remainingInsertItems = (ArrayList)newSortItems.Clone();
				if (fAssumeSame)
				{
					//assume we're converting a dummy item to a real one.
					//In that case, the real item should have same basic content as the dummy item we are replacing,
					//so we can replace the item at the same sortItem indices.
					foreach (object itemToInsert in newSortItems)
					{
						if (indicesOfSortItemsToRemove.Count > 0)
						{
							int iToReplace = indicesOfSortItemsToRemove[0];
							SortedObjects.RemoveAt(iToReplace);
							SortedObjects.Insert(iToReplace, itemToInsert);
							indicesOfSortItemsToRemove.RemoveAt(0);
							remainingInsertItems.RemoveAt(0);
						}
						else
						{
							break;
						}
					}
				}
			}
			// Although, ideally, during a dummy conversion there should be a one-to-one correspondence between
			// the sort items found for the dummy object, and the sort items generated for its real object,
			// it's possible that at the time we added the dummy item to the record sort list, it didn't
			// have the same properties matching a filter or sorter as the real item. Try to do the best we
			// can by removing remaining sort items for the dummy object and then adding any additional sort items
			// for the real object.

			// remove the remaining items.
			indicesOfSortItemsToRemove.Sort();
			indicesOfSortItemsToRemove.Reverse();
			foreach (int iToRemove in indicesOfSortItemsToRemove)
			{
				SortedObjects.RemoveAt(iToRemove);
			}
			// add the remaining items.
			if (m_sorter != null)
			{
				m_sorter.MergeInto(SortedObjects, remainingInsertItems);
			}
			else
			{
				// Add at the end.
				SortedObjects.AddRange(remainingInsertItems);
			}

			// update our current selected hvo, if necessary
			if (m_hvoCurrent == hvoToReplace)
				m_hvoCurrent = hvoNewObject;
			return newSortItems;
		}