C# Cloner.RegisterClonedObject方法代码示例

 protected TaskData(TaskData original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
   if (original.Data != null) {
     this.Data = new byte[original.Data.Length];
     Array.Copy(original.Data, this.Data, original.Data.Length);
   }
   this.LastUpdate = original.LastUpdate;
 }

    /// <summary>
    /// It is necessary to create new models of an unknown type with new trees in the simplifier.
    /// For this purpose the cloner is used by registering the new tree as already cloned object and invoking the clone mechanism.
    /// This results in a new model of the same type as the old one with an exchanged tree.
    /// </summary>
    /// <param name="tree">The new tree that should be included in the new object</param>
    /// <returns></returns>
    protected ISymbolicClassificationModel CreateModel(ISymbolicExpressionTree tree) {
      var cloner = new Cloner();
      cloner.RegisterClonedObject(Content.Model.SymbolicExpressionTree, tree);

      var model = (ISymbolicClassificationModel)Content.Model.Clone(cloner);
      model.RecalculateModelParameters(Content.ProblemData, Content.ProblemData.TrainingIndices);
      return model;
    }

 protected Job(Job original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
   this.OwnerUserId = original.OwnerUserId;
   this.DateCreated = original.DateCreated;
   this.ResourceNames = original.ResourceNames;
   this.Name = original.Name;
   this.Description = original.Description;
   this.Id = original.Id;
   this.Permission = original.Permission;
 }

 protected Calculator(Calculator original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
   if (original.tokens != null)
     tokens = original.tokens.ToList();
 }

 protected Benchmark(Benchmark original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
 }

 private BenchmarkAlgorithm(BenchmarkAlgorithm original, Cloner cloner) {
   if (original.ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
   cloner.RegisterClonedObject(original, this);
   name = original.name;
   description = original.description;
   parameters = cloner.Clone(original.parameters);
   readOnlyParameters = null;
   executionState = original.executionState;
   executionTime = original.executionTime;
   storeAlgorithmInEachRun = original.storeAlgorithmInEachRun;
   runsCounter = original.runsCounter;
   Runs = cloner.Clone(original.runs);
   results = cloner.Clone(original.results);
 }

 public override IDeepCloneable Clone(Cloner cloner) {
   // distance matrices are not cloned for performance reasons
   cloner.RegisterClonedObject(this, this);
   return this;
 }

 protected HiveItem(HiveItem original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
   this.Id = original.Id;
   modified = true;
 }

 protected OKBItem(OKBItem original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
   modified = true;
 }

 public override IDeepCloneable Clone(Cloner cloner) {
   foreach (ISymbol symbol in base.Symbols)
     if (!cloner.ClonedObjectRegistered(symbol))
       cloner.RegisterClonedObject(symbol, symbol);
   return new SymbolicExpressionTreeGrammar(this, cloner);
 }

    public override IOperation Apply() {
      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
      ResultCollection results = ResultsParameter.ActualValue;
      bool max = MaximizationParameter.ActualValue.Value;
      DoubleValue bestKnownQuality = BestKnownQualityParameter.ActualValue;

      if (results.ContainsKey(BestSolutionResultName) && !typeof(IScope).IsAssignableFrom(results[BestSolutionResultName].DataType)) {
        throw new InvalidOperationException(string.Format("Could not add best solution result, because there is already a result with the name \"{0}\" present in the result collection.", BestSolutionResultName));
      }

      int i = -1;
      if (!max)
        i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
      else i = qualities.Select((x, index) => new { index, x.Value }).OrderByDescending(x => x.Value).First().index;

      IEnumerable<IScope> scopes = new IScope[] { ExecutionContext.Scope };
      for (int j = 0; j < QualityParameter.Depth; j++)
        scopes = scopes.SelectMany(x => x.SubScopes);
      IScope currentBestScope = scopes.ToList()[i];

      if (bestKnownQuality == null ||
          max && qualities[i].Value > bestKnownQuality.Value
          || !max && qualities[i].Value < bestKnownQuality.Value) {
        BestKnownQualityParameter.ActualValue = new DoubleValue(qualities[i].Value);
      }

      if (!results.ContainsKey(BestSolutionResultName)) {
        var cloner = new Cloner();
        //avoid cloning of subscopes and the results collection that the solution is put in
        cloner.RegisterClonedObject(results, new ResultCollection());
        cloner.RegisterClonedObject(currentBestScope.SubScopes, new ScopeList());
        var solution = cloner.Clone(currentBestScope);

        results.Add(new Result(BestSolutionResultName, solution));
      } else {
        var bestSolution = (IScope)results[BestSolutionResultName].Value;
        string qualityName = QualityParameter.TranslatedName;
        if (bestSolution.Variables.ContainsKey(qualityName)) {
          double bestQuality = ((DoubleValue)bestSolution.Variables[qualityName].Value).Value;
          if (max && qualities[i].Value > bestQuality
              || !max && qualities[i].Value < bestQuality) {
            var cloner = new Cloner();
            //avoid cloning of subscopes and the results collection that the solution is put in
            cloner.RegisterClonedObject(results, new ResultCollection());
            cloner.RegisterClonedObject(currentBestScope.SubScopes, new ScopeList());
            var solution = cloner.Clone(currentBestScope);

            results[BestSolutionResultName].Value = solution;
          }
        }
      }
      return base.Apply();
    }

 protected Item(Item original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
 }

 protected DeepCloneable(DeepCloneable original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
 }

 protected MessageContainer(MessageContainer original, Cloner cloner) {
   cloner.RegisterClonedObject(original, this);
   this.Message = original.Message;
   this.TaskId = original.TaskId;
 }