C# Parameter类代码示例

		private Parameter ExtractActualComParameterObject(Parameter parameter)
		{
			var type = parameter.GetType();
			var method = type.GetMethod("GetParm", BindingFlags.Instance | BindingFlags.NonPublic);
			var actualParameter = method.Invoke(parameter, null);
			return (Parameter) actualParameter;
		}

 public ContainerGetUrlMethod()
 {
     Visibility = Visibility.Private;
     Name = "GetUrl";
     Parameters = new Parameter[] { };
     ReturnType = new Type(new Identifier("System", "Uri"));
 }

        public Method(MethodDefinition method)
        {
            Name = method.Name;
            NameWithTypes = BuildNameWithTypes(method);
            if (method.IsPublic)
                Access = "public";
            else if (method.IsFamily)
                Access = "protected";

            if(method.ReturnType.FullName != "System.Void")
                ReturnType = method.ReturnType.ToXdgUrl();

            XmlNode doc = Xdg.FindXmlDoc(method);
            if (doc != null)
            {
                Summary = doc.GetElementContent("summary");
                Remarks = doc.GetElementContent("remarks");
                ReturnDocs = doc.GetElementContent("returns");
            }

            Parameters = new List<Parameter>();
            foreach (ParameterDefinition p in method.Parameters)
            {
                Parameter param = new Parameter();
                param.Name = p.Name;
                param.Type = p.ParameterType.ToXdgUrl();

                if(doc != null)
                    param.Doc = doc.GetElementContent("param[@name=\""+p.Name+"\"]");

                Parameters.Add(param);
            }
        }

        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            var functionName = binder.Name;

            try
            {
                // convert arguments to Parameter
                var parameters = new Parameter[args.Length];

                for (int i = 0; i < args.Length; i++)
                {
                    parameters[i] = new Parameter(args[i]);
                }

                Function.SetEntRef(_entRef);
                result = Function.Call(functionName, typeof(object), parameters);

                return true;
            }
            catch (Exception ex)
            {
                Log.Error(ex);

                result = null;

                return false;
            }
        }

 static Parser()
 {
     CreateTrigger = delegate (DependencyObject target, string triggerText) {
         if (triggerText == null)
         {
             return ConventionManager.GetElementConvention(target.GetType()).CreateTrigger();
         }
         string str = triggerText.Replace("[", string.Empty).Replace("]", string.Empty).Replace("Event", string.Empty).Trim();
         return new System.Windows.Interactivity.EventTrigger { EventName = str };
     };
     InterpretMessageText = (target, text) => new ActionMessage { MethodName = Regex.Replace(text, "^Action", string.Empty).Trim() };
     CreateParameter = delegate (DependencyObject target, string parameterText) {
         Parameter actualParameter = new Parameter();
         if (parameterText.StartsWith("'") && parameterText.EndsWith("'"))
         {
             actualParameter.Value = parameterText.Substring(1, parameterText.Length - 2);
         }
         else if (MessageBinder.SpecialValues.ContainsKey(parameterText.ToLower()) || char.IsNumber(parameterText[0]))
         {
             actualParameter.Value = parameterText;
         }
         else if (target is FrameworkElement)
         {
             FrameworkElement fe = (FrameworkElement) target;
             string[] nameAndBindingMode = (from x in parameterText.Split(new char[] { ':' }) select x.Trim()).ToArray<string>();
             int index = nameAndBindingMode[0].IndexOf('.');
             View.ExecuteOnLoad(fe, (, ) => BindParameter(fe, actualParameter, (index == -1) ? nameAndBindingMode[0] : nameAndBindingMode[0].Substring(0, index), (index == -1) ? null : nameAndBindingMode[0].Substring(index + 1), (nameAndBindingMode.Length == 2) ? ((BindingMode) Enum.Parse(typeof(BindingMode), nameAndBindingMode[1], true)) : BindingMode.OneWay));
         }
         return actualParameter;
     };
 }

 public void SetControl(Parameter par)
 {
     NameLabel.InnerText = par.Name;
     DescriptionLabel.InnerText = par.Description;
     if (par.Type == "System.String")
     {
         TextInput.Visible = true;
         TextInput.Value = par.Value;
     }
     if (par.Type == "System.Integer")
     {
         NumInput.Visible = true;
         NumInput.Value = par.Value;
     }
     if (par.Type == "System.Boolean")
     {
         CheckInput.Visible = true;
         if (par.Value == "True")
         {
             CheckInput.Checked = true;
         }
         else
         {
             CheckInput.Checked = false;
         }
     }
 }

 public void Construct5()
 {
     var parameter = new Parameter("param1", 5.0);
     Assert.AreEqual("param1", parameter.Name);
     Assert.AreEqual(0, parameter.DispId);
     Assert.AreEqual("5", parameter.Value);
 }

        public void CreateWithIntTypeAndValue()
        {
            const int newParameterValue = 10;
            var parameter = new Parameter<int> {Value = newParameterValue};

            Assert.AreEqual(newParameterValue, parameter.Value);
        }

        public void CreateWithBooleanTypeAndValue()
        {
            const bool newParameterValue = true;
            var parameter = new Parameter<bool> { Value = newParameterValue };

            Assert.AreEqual(newParameterValue, parameter.Value);
        }

        public void DefaultValueForIntType()
        {
            var defaultParameterValue = new Parameter<int>().DefaultValue;
            const int expectedValue = 0;

            Assert.AreEqual(expectedValue, defaultParameterValue);
        }

        public void CreateWithIntTypeAndNoValue()
        {
            var parameter = new Parameter<int>();
            const int expectedValue = 0;

            Assert.AreEqual(expectedValue, parameter.Value);
        }

 public SMART_TARGET_CLOSEST_CREATURE()
     : base(19, "Closest creature")
 {
     parameters[0] = new CreatureParameter("CreatureEntry(0any)");
     parameters[1] = new Parameter("maxDist");
     parameters[2] = new Parameter("dead?");
 }

        /// <summary>
        ///     Creates a FunctionScalarProperty element (potentially within multiple ComplexProperty elements) that
        ///     maps the Property at the bottom of the passed in property chain to the passed in Parameter
        ///     within the passed in ModificationFunction.
        /// </summary>
        /// <param name="modificationFunction">ultimate parent for ScalarProperty created by this</param>
        /// <param name="propertyChain">property to be inserted, preceded by its ComplexProperty parents if appropriate</param>
        /// <param name="navPropPointingToProperty">
        ///     Optional - if present indicates the Scalar Property at
        ///     the bottom of the propertyChain was reached via a NavProp (propertyChain will have only 1 Property)
        /// </param>
        /// <param name="parameter">The sproc parameter to which we will map</param>
        internal CreateFunctionScalarPropertyTreeCommand(
            ModificationFunction modificationFunction, List<Property> propertyChain,
            NavigationProperty navPropPointingToProperty, Parameter parameter, string version)
        {
            CommandValidation.ValidateModificationFunction(modificationFunction);
            CommandValidation.ValidateParameter(parameter);
            if (null != navPropPointingToProperty)
            {
                CommandValidation.ValidateNavigationProperty(navPropPointingToProperty);
            }
            Debug.Assert(propertyChain.Count > 0, "Properties list should contain at least one element");

            _modificationFunction = modificationFunction;
            _propertyChain = propertyChain;
            _navPropPointingToProperty = navPropPointingToProperty;
            if (_navPropPointingToProperty != null)
            {
                Debug.Assert(
                    propertyChain.Count == 1,
                    "When creating a FunctionScalarProperty via a NavigationProperty propertyChain should have only 1 element, but it has "
                    + propertyChain.Count);
            }
            _parameter = parameter;
            Debug.Assert(
                string.IsNullOrEmpty(version)
                || ModelConstants.FunctionScalarPropertyVersionOriginal.Equals(version, StringComparison.Ordinal)
                || ModelConstants.FunctionScalarPropertyVersionCurrent.Equals(version, StringComparison.Ordinal),
                "version should be empty or " + ModelConstants.FunctionScalarPropertyVersionOriginal + " or "
                + ModelConstants.FunctionScalarPropertyVersionCurrent + ". Actual value: " + version);
            _version = version;
        }

        private static bool CheckForEnumValue(Parameter parameter, Type desugared)
        {
            var enumItem = parameter.DefaultArgument.Declaration as Enumeration.Item;
            if (enumItem != null)
            {
                parameter.DefaultArgument.String = string.Format("{0}{1}{2}.{3}",
                    desugared.IsPrimitiveType() ? "(int) " : string.Empty,
                    string.IsNullOrEmpty(enumItem.Namespace.Namespace.Name)
                        ? string.Empty
                        : enumItem.Namespace.Namespace.Name + ".", enumItem.Namespace.Name, enumItem.Name);
                return true;
            }

            var call = parameter.DefaultArgument.Declaration as Function;
            if (call != null || parameter.DefaultArgument.Class == StatementClass.BinaryOperator)
            {
                string @params = regexFunctionParams.Match(parameter.DefaultArgument.String).Groups[1].Value;
                if (@params.Contains("::"))
                    parameter.DefaultArgument.String = regexDoubleColon.Replace(@params, desugared + ".");
                else
                    parameter.DefaultArgument.String = regexName.Replace(@params, desugared + ".$1");
                return true;
            }
            return false;
        }

 private void EndBlock()
 {
     AddParameter(parameter);
     parameter = new Parameter();
     PullParent();
     parserState = ParserState.BeginParameterName;
 }