C# ParameterInfo.GetRequiredCustomModifiers方法代码示例

		private void SetSignature(Type returnType, ParameterInfo returnParameter, Type[] parameters,
		                          ParameterInfo[] baseMethodParameters)
		{
			builder.SetSignature(
				returnType,
#if SILVERLIGHT
				null,
				null,
#else
				returnParameter.GetRequiredCustomModifiers(),
				returnParameter.GetOptionalCustomModifiers(),
#endif
				parameters,
#if SILVERLIGHT
				null,
				null
#else
				baseMethodParameters.Select(x => x.GetRequiredCustomModifiers()).ToArray(),
				baseMethodParameters.Select(x => x.GetOptionalCustomModifiers()).ToArray()
#endif
				);
		}

        static private void AppendParameterInfo(ParameterInfo parameter, StringBuilder sb)
        {
            foreach (var attribute in parameter.GetCustomAttributesData())
            {
                // these are pseudo-custom attributes that are added by Reflection but don't appear in metadata as custom attributes:
                if (attribute.AttributeType != typeof(OptionalAttribute) &&
                    attribute.AttributeType != typeof(InAttribute) &&
                    attribute.AttributeType != typeof(OutAttribute) &&
                    attribute.AttributeType != typeof(MarshalAsAttribute))
                {
                    AppendCustomAttributeData(attribute, sb);
                    sb.Append(" ");
                }
            }
            foreach (var modreq in parameter.GetRequiredCustomModifiers())
            {
                sb.Append("modreq(");
                AppendType(modreq, sb);
                sb.Append(") ");
            }
            foreach (var modopt in parameter.GetOptionalCustomModifiers())
            {
                sb.Append("modopt(");
                AppendType(modopt, sb);
                sb.Append(") ");
            }

            int length = sb.Length;
            AppendParameterAttributes(sb, parameter.Attributes, all: false);
            if (sb.Length > length)
            {
                sb.Append(" ");
            }

            AppendType(parameter.ParameterType, sb);
            if (!string.IsNullOrWhiteSpace(parameter.Name)) // If this is not the 'return' parameter
            {
                sb.Append(" ");
                sb.Append(parameter.Name);

                var defaultValue = parameter.RawDefaultValue;
                if (defaultValue != DBNull.Value)
                {
                    AppendValue(defaultValue, sb);
                }
            }
        }

        private static bool ParameterTypeMatches(Type type, ParameterInfo param)
        {
            if (!type.IsEquivalentTo(param.ParameterType))
            {
                return false;
            }

            // TODO (tomat): how expensive is GetOptional/GetRequiredCustomModifiers?
            ModifiedType modified = type as ModifiedType;
            return IsEquivalentTo(modified != null ? modified.OptionalModifiers : null, param.GetOptionalCustomModifiers())
                && IsEquivalentTo(modified != null ? modified.RequiredModifiers : null, param.GetRequiredCustomModifiers());
        }

        /// <summary>
        /// Verifies that two parameters are equivalent.
        /// </summary>
        /// <param name="actual">The actual parameter information.</param>
        /// <param name="expected">The expected parameter information.</param>
        private static void AreParametersEquivalent(ParameterInfo actual, ParameterInfo expected)
        {
            // Check parameter properties.
            Assert.That(actual.Name, Is.EqualTo(expected.Name));
            Assert.That(actual.IsIn, Is.EqualTo(expected.IsIn));
            Assert.That(actual.IsLcid, Is.EqualTo(expected.IsLcid));
            Assert.That(actual.IsOptional, Is.EqualTo(expected.IsOptional));
            Assert.That(actual.IsOut, Is.EqualTo(expected.IsOut));
            Assert.That(actual.IsRetval, Is.EqualTo(expected.IsRetval));
            Assert.That(actual.Position, Is.EqualTo(expected.Position));

            // Check parameter attributes.
            Assert.That(actual.Attributes, Is.EqualTo(expected.Attributes));

            // Check parameter type.
            AreTypesEquivalent(actual.ParameterType, expected.ParameterType);

            // Check default value.
            Assert.That(actual.DefaultValue, Is.EqualTo(expected.DefaultValue));
            Assert.That(actual.RawDefaultValue, Is.EqualTo(expected.RawDefaultValue));

            // Check custom modifiers.
            Assert.That(actual.GetOptionalCustomModifiers(), Is.EqualTo(expected.GetOptionalCustomModifiers()));
            Assert.That(actual.GetRequiredCustomModifiers(), Is.EqualTo(expected.GetRequiredCustomModifiers()));
        }

		private void SetSignature(Type returnType, ParameterInfo returnParameter, Type[] parameters,
		                          ParameterInfo[] baseMethodParameters)
		{
			builder.SetSignature(
				returnType,
#if FEATURE_EMIT_CUSTOMMODIFIERS
				returnParameter.GetRequiredCustomModifiers(),
				returnParameter.GetOptionalCustomModifiers(),
#else
				null,
				null,
#endif
				parameters,
#if FEATURE_EMIT_CUSTOMMODIFIERS
				baseMethodParameters.Select(x => x.GetRequiredCustomModifiers()).ToArray(),
				baseMethodParameters.Select(x => x.GetOptionalCustomModifiers()).ToArray()
#else
				null,
				null
#endif
			);
		}