C# ReadOnlyCollection.GetEnumerator方法代码示例

        public bool SelectOption(ReadOnlyCollection<IWebElement> fromOptions, string selectThis, bool setSelected, bool allowMultipleSelect)
        {
            bool matchMade = false;
            IEnumerator<IWebElement> allOptions = fromOptions.GetEnumerator();

            while (allOptions.MoveNext())
            {
                IWebElement option = allOptions.Current;
                bool matchThisTime = SelectOption(option, selectThis);
                if (matchThisTime)
                {
                    if (setSelected)
                    {
                        option.Select();
                    }
                    else if (option.Selected)
                    {
                        option.Toggle();
                    }
                }

                matchMade |= matchThisTime;
                if (matchMade && !allowMultipleSelect)
                {
                    return true;
                }
            }

            return matchMade;
        }

 /// <summary>
 /// Save a collection of ClipData to HardDisk
 /// </summary>
 /// <param name="clipData">The collection of ClipData to save</param>
 /// <param name="clipName">The name of the file</param>
 public static void SaveToFile(ReadOnlyCollection<DataClip> clipData, string clipName)
 {
     //Get the enumeration of the clipboard data
     IEnumerator<DataClip> cData = clipData.GetEnumerator();
     //Init a counter
     int i = 0;
     //Delete the folder, if already exists
     if (Directory.Exists(clipName))
     {
         Directory.Delete(clipName,true);
     }
     //Open the directory on which save the files
     DirectoryInfo di= Directory.CreateDirectory(clipName);
     
     while (cData.MoveNext())
     {
         //Init the serializer
         XmlSerializer xml = new XmlSerializer(typeof(DataClip));
         // To write to a file, create a StreamWriter object.
         using (StreamWriter sw = new StreamWriter(di.FullName + @"\" + i.ToString() + ".cli",false))
         {
             //Serialize the clipboard data
             xml.Serialize(sw, cData.Current);
         }
         
         i++;
     }
  }

        /// <summary>
        /// Empty the Clipboard and Restore to system clipboard data contained in a collection of ClipData objects
        /// </summary>
        /// <param name="clipData">The collection of ClipData containing data stored from clipboard</param>
        /// <returns></returns>    
        public static bool SetClipboard(ReadOnlyCollection<DataClip> clipData)
        {
            //Open clipboard to allow its manipultaion
            if (!Win32ClipboardAPI.OpenClipboard(IntPtr.Zero))
                return false;
            
            //Clear the clipboard
            EmptyClipboard();
                        
            //Get an Enumerator to iterate into each ClipData contained into the collection
            IEnumerator<DataClip> cData = clipData.GetEnumerator();
            while( cData.MoveNext())
            {
                DataClip cd = cData.Current;

                //Get the pointer for inserting the buffer data into the clipboard
                IntPtr alloc = Win32MemoryAPI.GlobalAlloc(Win32MemoryAPI.GMEM_MOVEABLE | Win32MemoryAPI.GMEM_DDESHARE, cd.Size);
                IntPtr gLock = Win32MemoryAPI.GlobalLock(alloc);

                //Clopy the buffer of the ClipData into the clipboard
                if ((int)cd.Size>0)
                {
                    Marshal.Copy(cd.Buffer, 0, gLock, cd.Buffer.GetLength(0));
                }
                else
                {
                }
                //Release pointers 
                Win32MemoryAPI.GlobalUnlock(alloc);
                Win32ClipboardAPI.SetClipboardData(cd.Format, alloc);
            };
            //Close the clipboard to realese unused resources
            Win32ClipboardAPI.CloseClipboard();
            return true;
        }

        public void ReadOnlySet_getEnumerator()
        {
            List<Int32> source = new List<Int32>();
            ReadOnlyCollection<Int32> actual = new ReadOnlyCollection<int>( source );

            Assert.IsNotNull( actual.GetEnumerator() );
        }

        public void TestCollection()
        {
            // Default ctor.
            var data = Enumerable.Range(1, 5).ToArray();
            var col = new ReadOnlyCollection<int>(data);

            Assert.AreEqual(5, col.Count);
            Assert.IsTrue(col.IsReadOnly);
            CollectionAssert.AreEqual(data, col);

            Assert.IsTrue(col.GetEnumerator().MoveNext());
            Assert.IsTrue(((IEnumerable) col).GetEnumerator().MoveNext());

            Assert.IsTrue(col.Contains(4));

            var arr = new int[5];
            col.CopyTo(arr, 0);
            CollectionAssert.AreEqual(data, arr);

            Assert.Throws<NotSupportedException>(() => col.Add(1));
            Assert.Throws<NotSupportedException>(() => col.Clear());
            Assert.Throws<NotSupportedException>(() => col.Remove(1));
        }

		private bool CheckIfBookmarkExistInCollection(string bookmarkName, ReadOnlyCollection<BookmarkInfo> bookmarks)
		{
			bool flag;
			IEnumerator<BookmarkInfo> enumerator = bookmarks.GetEnumerator();
			using (enumerator)
			{
				while (enumerator.MoveNext())
				{
					BookmarkInfo current = enumerator.Current;
					if (bookmarkName != current.BookmarkName)
					{
						continue;
					}
					flag = true;
					return flag;
				}
				return false;
			}
			return flag;
		}