C# RepeatedField类代码示例

 public void Add_SingleItem()
 {
     var list = new RepeatedField<string>();
     list.Add("foo");
     Assert.AreEqual(1, list.Count);
     Assert.AreEqual("foo", list[0]);
 }

 public void Add_Sequence()
 {
     var list = new RepeatedField<string>();
     list.Add(new[] { "foo", "bar" });
     Assert.AreEqual(2, list.Count);
     Assert.AreEqual("foo", list[0]);
     Assert.AreEqual("bar", list[1]);
 }

 public void AddRange_SlowPath()
 {
     var list = new RepeatedField<string>();
     list.AddRange(new[] { "foo", "bar" }.Select(x => x));
     Assert.AreEqual(2, list.Count);
     Assert.AreEqual("foo", list[0]);
     Assert.AreEqual("bar", list[1]);
 }

 public void Add_RepeatedField()
 {
     var list = new RepeatedField<string> { "original" };
     list.Add(new RepeatedField<string> { "foo", "bar" });
     Assert.AreEqual(3, list.Count);
     Assert.AreEqual("original", list[0]);
     Assert.AreEqual("foo", list[1]);
     Assert.AreEqual("bar", list[2]);
 }

 public void NullValuesRejected()
 {
     var list = new RepeatedField<string>();
     Assert.Throws<ArgumentNullException>(() => list.Add((string)null));
     Assert.Throws<ArgumentNullException>(() => list.Add((IEnumerable<string>)null));
     Assert.Throws<ArgumentNullException>(() => list.Add((RepeatedField<string>)null));
     Assert.Throws<ArgumentNullException>(() => list.Contains(null));
     Assert.Throws<ArgumentNullException>(() => list.IndexOf(null));
 }

        public void AddEntriesFrom_Message()
        {
            var message1 = new ForeignMessage { C = 2000 };
            var message2 = new ForeignMessage { C = -250 };

            uint tag = WireFormat.MakeTag(10, WireFormat.WireType.LengthDelimited);
            var stream = new MemoryStream();
            var output = new CodedOutputStream(stream);
            output.WriteTag(tag);
            output.WriteMessage(message1);
            output.WriteTag(tag);
            output.WriteMessage(message2);
            output.Flush();
            stream.Position = 0;

            var field = new RepeatedField<ForeignMessage>();
            var input = new CodedInputStream(stream);
            input.AssertNextTag(tag);
            field.AddEntriesFrom(input, FieldCodec.ForMessage(tag, ForeignMessage.Parser));
            CollectionAssert.AreEqual(new[] { message1, message2}, field);
            Assert.IsTrue(input.IsAtEnd);
        }

 public void ToString_Integers()
 {
     var list = new RepeatedField<int> { 5, 10, 20 };
     var text = list.ToString();
     Assert.AreEqual("[ 5, 10, 20 ]", text);
 }

 public void IList_Insert()
 {
     IList list = new RepeatedField<string> { "first", "second" };
     list.Insert(1, "middle");
     CollectionAssert.AreEqual(new[] { "first", "middle", "second" }, list);
 }

 public void IList_IsSynchronized()
 {
     IList list = new RepeatedField<string> { "first", "second" };
     Assert.IsFalse(list.IsSynchronized);
 }

        public void TestNegativeEnumArray()
        {
            int arraySize = 1 + 1 + (11 * 5);
            int msgSize = arraySize;
            byte[] bytes = new byte[msgSize];
            CodedOutputStream output = new CodedOutputStream(bytes);
            uint tag = WireFormat.MakeTag(8, WireFormat.WireType.Varint);
            for (int i = 0; i >= -5; i--)
            {
                output.WriteTag(tag);
                output.WriteEnum(i);
            }

            Assert.AreEqual(0, output.SpaceLeft);

            CodedInputStream input = new CodedInputStream(bytes);
            tag = input.ReadTag();

            RepeatedField<SampleEnum> values = new RepeatedField<SampleEnum>();
            values.AddEntriesFrom(input, FieldCodec.ForEnum(tag, x => (int)x, x => (SampleEnum)x));

            Assert.AreEqual(6, values.Count);
            Assert.AreEqual(SampleEnum.None, values[0]);
            Assert.AreEqual(((SampleEnum)(-1)), values[1]);
            Assert.AreEqual(SampleEnum.NegativeValue, values[2]);
            Assert.AreEqual(((SampleEnum)(-3)), values[3]);
            Assert.AreEqual(((SampleEnum)(-4)), values[4]);
            Assert.AreEqual(((SampleEnum)(-5)), values[5]);
        }

 public void CalculateSize_FixedSizeNonPacked()
 {
     var list = new RepeatedField<int> { 1, 500, 1 };
     var tag = WireFormat.MakeTag(1, WireFormat.WireType.Fixed32);
     // 5 bytes for the each entry
     Assert.AreEqual(15, list.CalculateSize(FieldCodec.ForSFixed32(tag)));
 }

 public void ToString_Timestamp()
 {
     var list = new RepeatedField<Timestamp> { Timestamp.FromDateTime(new DateTime(2015, 10, 1, 12, 34, 56, DateTimeKind.Utc)) };
     var text = list.ToString();
     Assert.AreEqual("[ \"2015-10-01T12:34:56Z\" ]", text);
 }

 public void ToString_Empty()
 {
     var list = new RepeatedField<TestAllTypes> { };
     var text = list.ToString();
     Assert.AreEqual("[ ]", text);
 }

 public void IList_IsFixedSize()
 {
     var field = new RepeatedField<string> { "first", "second" };
     IList list = field;
     Assert.IsFalse(list.IsFixedSize);
 }

 public void IList_Remove()
 {
     IList list = new RepeatedField<string> { "first", "second" };
     list.Remove("third"); // No-op, no exception
     list.Remove(new object()); // No-op, no exception
     list.Remove("first");
     CollectionAssert.AreEqual(new[] { "second" }, list);
 }