C# Parameter.Clone方法代码示例

        public void TestClone()
        {
            IDataElement elem = new DataElement(new TranslateableLanguageItem("1"), new TranslateableLanguageItem("1"), DataType.String, "name");
            Parameter param = new Parameter(
                "param1", 
                 elem);

            IParameter copyOfParam = param.Clone() as IParameter;
            Assert.IsNotNull(copyOfParam);
            Assert.AreNotEqual(param.Identifier, copyOfParam.Identifier);
            Assert.AreEqual(param.ReadOnly, copyOfParam.ReadOnly);

            IDataElement copyOfElem = copyOfParam.Value;
            Assert.IsNotNull(copyOfElem);
            Assert.AreEqual(elem.Name.Value, copyOfElem.Name.Value);
            Assert.AreEqual(elem.DisplayName.Value, copyOfElem.DisplayName.Value);
            Assert.AreEqual(elem.Type, copyOfElem.Type);

            Assert.AreEqual("name", (string)copyOfElem.Data);
        }

		protected override void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
		{
			args = new Arguments (4);

			if (IdentifierType != null)
				expr = CreateCastExpression (expr);

			args.Add (new Argument (expr));

			outer_selector.SetParameter (parameter.Clone ());
			var lambda = new LambdaExpression (outer_selector.StartLocation);
			lambda.Block = outer_selector;
			args.Add (new Argument (lambda));

			inner_selector.SetParameter (new ImplicitLambdaParameter (identifier.Name, identifier.Location));
			lambda = new LambdaExpression (inner_selector.StartLocation);
			lambda.Block = inner_selector;
			args.Add (new Argument (lambda));

			base.CreateArguments (ec, parameter, ref args);
		}

		protected override Parameter CreateChildrenParameters (Parameter parameter)
		{
			return new QueryBlock.TransparentParameter (parameter.Clone (), GetIntoVariable ());
		}

		protected override void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
		{
			if (args == null) {
				if (IdentifierType != null)
					expr = CreateCastExpression (expr);

				base.CreateArguments (ec, parameter.Clone (), ref args);
			}

			Expression result_selector_expr;
			QueryBlock result_block;

			var target = GetIntoVariable ();
			var target_param = new ImplicitLambdaParameter (target.Name, target.Location);

			//
			// When select follows use it as a result selector
			//
			if (next is Select) {
				result_selector_expr = next.Expr;

				result_block = next.block;
				result_block.SetParameters (parameter, target_param);

				next = next.next;
			} else {
				result_selector_expr = CreateRangeVariableType (ec, parameter, target, new SimpleName (target.Name, target.Location));

				result_block = new QueryBlock (block.Parent, block.StartLocation);
				result_block.SetParameters (parameter, target_param);
			}

			LambdaExpression result_selector = new LambdaExpression (Location);
			result_selector.Block = result_block;
			result_selector.Block.AddStatement (new ContextualReturn (result_selector_expr));

			args.Add (new Argument (result_selector));
		}

    public virtual Differences VisitParameter(Parameter parameter1, Parameter parameter2){
      Differences differences = new Differences(parameter1, parameter2);
      if (parameter1 == null || parameter2 == null){
        if (parameter1 != parameter2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
        return differences;
      }
      Parameter changes = (Parameter)parameter2.Clone();
      Parameter deletions = (Parameter)parameter2.Clone();
      Parameter insertions = (Parameter)parameter2.Clone();

      AttributeList attrChanges, attrDeletions, attrInsertions;
      Differences diff = this.VisitAttributeList(parameter1.Attributes, parameter2.Attributes, out attrChanges, out attrDeletions, out attrInsertions);
      if (diff == null){Debug.Assert(false); return differences;}
      changes.Attributes = attrChanges;
      deletions.Attributes = attrDeletions;
      insertions.Attributes = attrInsertions;
      differences.NumberOfDifferences += diff.NumberOfDifferences;
      differences.NumberOfSimilarities += diff.NumberOfSimilarities;

      diff = this.VisitExpression(parameter1.DefaultValue, parameter2.DefaultValue);
      if (diff == null){Debug.Assert(false); return differences;}
      changes.DefaultValue = diff.Changes as Expression;
      deletions.DefaultValue = diff.Deletions as Expression;
      insertions.DefaultValue = diff.Insertions as Expression;
      Debug.Assert(diff.Changes == changes.DefaultValue && diff.Deletions == deletions.DefaultValue && diff.Insertions == insertions.DefaultValue);
      differences.NumberOfDifferences += diff.NumberOfDifferences;
      differences.NumberOfSimilarities += diff.NumberOfSimilarities;

      if (parameter1.Flags == parameter2.Flags) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;
      if (this.ValuesAreEqual(parameter1.MarshallingInformation,parameter2.MarshallingInformation)) differences.NumberOfSimilarities++; else differences.NumberOfDifferences++;      

      diff = this.VisitIdentifier(parameter1.Name, parameter2.Name);
      if (diff == null){Debug.Assert(false); return differences;}
      changes.Name = diff.Changes as Identifier;
      deletions.Name = diff.Deletions as Identifier;
      insertions.Name = diff.Insertions as Identifier;
      Debug.Assert(diff.Changes == changes.Name && diff.Deletions == deletions.Name && diff.Insertions == insertions.Name);
      differences.NumberOfDifferences += diff.NumberOfDifferences;
      differences.NumberOfSimilarities += diff.NumberOfSimilarities;

      if (differences.NumberOfDifferences == 0){
        differences.Changes = null;
        differences.Deletions = null;
        differences.Insertions = null;
      }else{
        differences.Changes = changes;
        differences.Deletions = deletions;
        differences.Insertions = insertions;
      }
      return differences;
    }

 public override Expression VisitParameter(Parameter parameter)
 {
     if (parameter == null) return null;
     Parameter dup = (Parameter)this.DuplicateFor[parameter.UniqueKey];
     if (dup != null)
     {
         if (dup.DeclaringMethod == null) dup.DeclaringMethod = this.TargetMethod;
         return dup;
     }
     this.DuplicateFor[parameter.UniqueKey] = dup = (Parameter)parameter.Clone();
     if (dup.MarshallingInformation != null)
         dup.MarshallingInformation = dup.MarshallingInformation.Clone();
     dup.DeclaringMethod = this.TargetMethod;
     return base.VisitParameter(dup);
 }

        public void HashCodeForMinInt()
        {
            var parameter = new Parameter<int>();
            parameter.GetHashCode();

            var clonedParameter = (Parameter) parameter.Clone();

            // stack overflow was thrown
        }

 public void CloneDateTimeParameter()
 {
     var dateTimeParameter = new Parameter<DateTime>("original parameter");
     dateTimeParameter.Value = new DateTime(2000,1,1);
     
     var clone = (Parameter<DateTime>)dateTimeParameter.Clone();
     
     Assert.AreEqual(dateTimeParameter.Value,clone.Value);
 }

        public void CloneParameter()
        {
            var parameter = new Parameter<int>("original parameter", new Unit("test quantity", "TQ"))
                                {ValueType = typeof (double)};

            var clonedParameter = (Parameter) parameter.Clone();

            Assert.AreEqual(parameter.Name, clonedParameter.Name);
            Assert.AreEqual(parameter.Unit,clonedParameter.Unit);
            Assert.AreEqual(parameter.ValueType,clonedParameter.ValueType);
        }

		protected virtual void CreateArguments (ResolveContext ec, Parameter parameter, ref Arguments args)
		{
			args = new Arguments (2);

			LambdaExpression selector = new LambdaExpression (loc);

			block.SetParameter (parameter.Clone ());
			selector.Block = block;
			selector.Block.AddStatement (new ContextualReturn (expr));

			args.Add (new Argument (selector));
		}