C# OrderedDictionary.AsReadOnly方法代码示例

        public static IDictionary GetReadOnlyDictionary(IDictionary dictionary)
        {
            Guard.ArgumentNotNull(dictionary, "dictionary");

            OrderedDictionary result = new OrderedDictionary();
            foreach (DictionaryEntry entry in dictionary)
            {
                result.Add(entry.Key, entry.Value);
            }
            return result.AsReadOnly();
        }

		private void Common (OrderedDictionary od)
		{
			Assert.IsNotNull (od.GetEnumerator (), "GetEnumerator");
			Assert.AreEqual (0, od.Count, "Count-0");
			Assert.IsFalse (od.IsReadOnly, "IsReadOnly");
			od.Add ("a", "1");
			Assert.AreEqual (1, od.Count, "Count-1");
			od["a"] = "11";
			Assert.AreEqual ("11", od["a"], "this[string]");
			od[0] = "111";
			Assert.AreEqual ("111", od[0], "this[int]");

			DictionaryEntry[] array = new DictionaryEntry[2];
			od.CopyTo (array, 1);

			Assert.AreEqual ("111", ((DictionaryEntry)array[1]).Value, "CopyTo");
			Assert.AreEqual (1, od.Keys.Count, "Keys");
			Assert.AreEqual (1, od.Values.Count, "Values");
			Assert.IsTrue (od.Contains ("a"), "Contains(a)");
			Assert.IsFalse (od.Contains ("111"), "Contains(111)");

			od.Insert (0, "b", "2");
			Assert.AreEqual (2, od.Count, "Count-2");
			od.Add ("c", "3");
			Assert.AreEqual (3, od.Count, "Count-3");

			OrderedDictionary ro = od.AsReadOnly ();

			od.RemoveAt (2);
			Assert.AreEqual (2, od.Count, "Count-4");
			Assert.IsFalse (od.Contains ("c"), "Contains(c)");

			od.Remove ("b");
			Assert.AreEqual (1, od.Count, "Count-5");
			Assert.IsFalse (od.Contains ("b"), "Contains(b)");

			od.Clear ();
			Assert.AreEqual (0, od.Count, "Count-6");

			Assert.IsTrue (ro.IsReadOnly, "IsReadOnly-2");
			// it's a read-only reference
			Assert.AreEqual (0, od.Count, "Count-7");
		}

 public void IsReadOnlyTests()
 {
     var d = new OrderedDictionary();
     Assert.False(d.IsReadOnly);
     var d2 = d.AsReadOnly();
     Assert.True(d2.IsReadOnly);
 }

        public void AsReadOnlyTests()
        {
            var _d = new OrderedDictionary();
            _d["foo"] = "bar";
            _d[(object)13] = 37;

            var d = _d.AsReadOnly();
            Assert.True(d.IsReadOnly);
            Assert.Equal("bar", d["foo"]);
            Assert.Equal(37, d[(object)13]);
            Assert.Throws<NotSupportedException>(() => { d["foo"] = "moooooooooaaah"; });
            Assert.Throws<NotSupportedException>(() => { d["asdasd"] = "moooooooooaaah"; });
            Assert.Equal(null, d["asdasd"]);
            Assert.Throws<ArgumentNullException>(() => { var a = d[null]; });
        }

 public void IsFixedSizeTests()
 {
     var d = new OrderedDictionary();
     IDictionary dic = d;
     IDictionary rodic = d.AsReadOnly();
     Assert.False(dic.IsFixedSize);
     Assert.True(rodic.IsFixedSize);
 }

 public ModelDataMethodResult(object returnValue, OrderedDictionary outputParameters) {
     ReturnValue = returnValue;
     outputParameters = outputParameters ?? new OrderedDictionary(StringComparer.OrdinalIgnoreCase);
     _outputParameters = outputParameters.AsReadOnly();
 }

		public void GetObjectData_IEqualityComparer ()
		{
			EqualityComparer comparer = new EqualityComparer ();
			OrderedDictionary coll = new OrderedDictionary (comparer);
			coll.Add ("a", "1");
			coll.Add ("b", "2");
			coll = coll.AsReadOnly ();

			SerializationInfo si = new SerializationInfo (typeof (OrderedDictionary), new FormatterConverter ());
			coll.GetObjectData (si, new StreamingContext ());
			foreach (SerializationEntry se in si) {
				switch (se.Name) {
				case "KeyComparer":
					Assert.AreSame (comparer, se.Value, se.Name);
					break;
				case "ReadOnly":
					Assert.IsTrue ((bool) se.Value, se.Name);
					break;
				case "InitialCapacity":
					Assert.AreEqual (0, se.Value, se.Name);
					break;
				case "ArrayList":
					Assert.AreEqual (2, ((object[]) se.Value).Length, se.Name);
					break;
				default:
					string msg = String.Format ("Unexpected {0} information of type {1} with value '{2}'.",
						se.Name, se.ObjectType, se.Value);
					Assert.Fail (msg);
					break;
				}
			}
		}

//.........这里部分代码省略.........
                BindingFlags.Public |
                BindingFlags.Instance |
                BindingFlags.Static |
                BindingFlags.FlattenHierarchy);

            MethodInfo matchedMethod = null;
            ParameterInfo[] matchedMethodParameters = null;


            int requiredParameterCount;
            if (oldDataObject == null) {
                requiredParameterCount = 1;
            }
            else {
                if (newDataObject == null) {
                    requiredParameterCount = 1;
                }
                else {
                    requiredParameterCount = 2;
                }
            }


            foreach (MethodInfo mi in methods) {
                if (String.Equals(methodName, mi.Name, StringComparison.OrdinalIgnoreCase)) {
                    if (mi.IsGenericMethodDefinition) {
                        // We do not support binding to generic methods, e.g. public void DoSomething<T>(T t)
                        continue;
                    }

                    ParameterInfo[] methodParameters = mi.GetParameters();

                    int methodParametersCount = methodParameters.Length;

                    if (methodParametersCount == requiredParameterCount) {
                        if (requiredParameterCount == 1 &&
                            methodParameters[0].ParameterType == dataObjectType) {
                            // Only one parameter, of proper type
                            // This is only valid for insert, delete, and non-optimistic update
                            matchedMethod = mi;
                            matchedMethodParameters = methodParameters;
                            break;
                        }
                        if (requiredParameterCount == 2 &&
                            methodParameters[0].ParameterType == dataObjectType &&
                            methodParameters[1].ParameterType == dataObjectType) {
                            // Two parameters of proper type in Update
                            // This is only valid for optimistic update
                            matchedMethod = mi;
                            matchedMethodParameters = methodParameters;
                            break;
                        }
                    }
                }
            }

            if (matchedMethod == null) {
                throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_MethodNotFoundForDataObject, _owner.ID, methodName, dataObjectType.FullName));
            }

            Debug.Assert(matchedMethodParameters != null, "Method parameters should not be null if a method was found");

            // Set up parameter array for method call
            OrderedDictionary parameters = new OrderedDictionary(2, StringComparer.OrdinalIgnoreCase);

            if (oldDataObject == null) {
                parameters.Add(matchedMethodParameters[0].Name, newDataObject);
            }
            else {
                if (newDataObject == null) {
                    parameters.Add(matchedMethodParameters[0].Name, oldDataObject);
                }
                else {
                    // We know that we matched on 2 objects for a optimistic update.
                    // Match the parameters based on the format string so we know which one is the old
                    // object and which is the new, then pass objects into the method in the correct order.
                    string param0Name = matchedMethodParameters[0].Name;
                    string param1Name = matchedMethodParameters[1].Name;
                    string formattedParamName = String.Format(CultureInfo.InvariantCulture, OldValuesParameterFormatString, param0Name);
                    if (String.Equals(param1Name, formattedParamName, StringComparison.OrdinalIgnoreCase)) {
                        parameters.Add(param0Name, newDataObject);
                        parameters.Add(param1Name, oldDataObject);
                    }
                    else {
                        formattedParamName = String.Format(CultureInfo.InvariantCulture, OldValuesParameterFormatString, param1Name);
                        if (String.Equals(param0Name, formattedParamName, StringComparison.OrdinalIgnoreCase)) {
                            parameters.Add(param0Name, oldDataObject);
                            parameters.Add(param1Name, newDataObject);
                        }
                        else {
                            throw new InvalidOperationException(SR.GetString(SR.ObjectDataSourceView_NoOldValuesParams, _owner.ID));
                        }
                    }
                }
            }

            // The parameters collection is always readonly in this case since we
            // do not want the user adding/removing the known objects.
            return new ObjectDataSourceMethod(operation, type, matchedMethod, parameters.AsReadOnly());
        }

 private ObjectDataSourceMethod GetResolvedMethodData(Type type, string methodName, Type dataObjectType, object oldDataObject, object newDataObject, DataSourceOperation operation)
 {
     int num;
     MethodInfo[] methods = type.GetMethods(BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance);
     MethodInfo methodInfo = null;
     ParameterInfo[] infoArray2 = null;
     if (oldDataObject == null)
     {
         num = 1;
     }
     else if (newDataObject == null)
     {
         num = 1;
     }
     else
     {
         num = 2;
     }
     foreach (MethodInfo info2 in methods)
     {
         if (string.Equals(methodName, info2.Name, StringComparison.OrdinalIgnoreCase) && !info2.IsGenericMethodDefinition)
         {
             ParameterInfo[] parameters = info2.GetParameters();
             if (parameters.Length == num)
             {
                 if ((num == 1) && (parameters[0].ParameterType == dataObjectType))
                 {
                     methodInfo = info2;
                     infoArray2 = parameters;
                     break;
                 }
                 if (((num == 2) && (parameters[0].ParameterType == dataObjectType)) && (parameters[1].ParameterType == dataObjectType))
                 {
                     methodInfo = info2;
                     infoArray2 = parameters;
                     break;
                 }
             }
         }
     }
     if (methodInfo == null)
     {
         throw new InvalidOperationException(System.Web.SR.GetString("ObjectDataSourceView_MethodNotFoundForDataObject", new object[] { this._owner.ID, methodName, dataObjectType.FullName }));
     }
     OrderedDictionary dictionary = new OrderedDictionary(2, StringComparer.OrdinalIgnoreCase);
     if (oldDataObject == null)
     {
         dictionary.Add(infoArray2[0].Name, newDataObject);
     }
     else if (newDataObject == null)
     {
         dictionary.Add(infoArray2[0].Name, oldDataObject);
     }
     else
     {
         string name = infoArray2[0].Name;
         string a = infoArray2[1].Name;
         string b = string.Format(CultureInfo.InvariantCulture, this.OldValuesParameterFormatString, new object[] { name });
         if (string.Equals(a, b, StringComparison.OrdinalIgnoreCase))
         {
             dictionary.Add(name, newDataObject);
             dictionary.Add(a, oldDataObject);
         }
         else
         {
             b = string.Format(CultureInfo.InvariantCulture, this.OldValuesParameterFormatString, new object[] { a });
             if (!string.Equals(name, b, StringComparison.OrdinalIgnoreCase))
             {
                 throw new InvalidOperationException(System.Web.SR.GetString("ObjectDataSourceView_NoOldValuesParams", new object[] { this._owner.ID }));
             }
             dictionary.Add(name, oldDataObject);
             dictionary.Add(a, newDataObject);
         }
     }
     return new ObjectDataSourceMethod(operation, type, methodInfo, dictionary.AsReadOnly());
 }