public InMemoryMembershipTable(DeepCopier deepCopier) { this.deepCopier = deepCopier; siloTable = new Dictionary <SiloAddress, Tuple <MembershipEntry, string> >(); lastETagCounter = 0; tableVersion = new TableVersion(0, NewETag()); }
//Action public void MakeTheCheckedBill(string path, string course, string pathtosave) { DeepCopier copier = new DeepCopier(); GetDataFromBill(path); GammaMod.GetAll(); foreach (var billposition in bills) { FurcomMod.GetByName(billposition.Name.GeneralName); FurcomIdReceiver IdReceiver = new FurcomIdReceiver(); FurcomModel loc = (FurcomModel)FurcomMod; string id = IdReceiver.GetIdFromFurcomProductDescr(loc.SelectedData[0].Description); CheckerGammaList GetterFromGamma = new CheckerGammaList(); GammaModel loc2 = (GammaModel)GammaMod; GetterFromGamma.FindOfferInGammaBase(id, loc2.SelectedData); offer result = GetterFromGamma.FoundOffer; BillData newbilldata = copier.DeepClone <BillData>(billposition); // это надо проверить decimal targetprice = ConvertRURintoBYN(course, result.Price); ChangeBillDataAmounts(newbilldata, targetprice); OutputBills.Add(newbilldata); } BillFormer former = new BillFormer(); former.FormBill(pathtosave, OutputBills, Raredata); }
public async Task SaveSnapshotAsync(IAggregateRoot aggregateRoot, Type aggregateRootType, int publishedVersion) { if (aggregateRoot == null) { throw new ArgumentNullException(nameof(aggregateRoot)); } if (publishedVersion % _aggregateSnapshotConfiguration.VersionInterval != 0) { return; } var copiedAggregateRoot = DeepCopier.Copy(aggregateRoot); var aggregateRootJson = _aggregateSnapshotSerializer.Serialize(copiedAggregateRoot); var aggregateRootTypeName = _typeNameProvider.GetTypeName(aggregateRootType); var snapshot = new Snapshot() { CreationTime = DateTime.UtcNow, ModificationTime = DateTime.UtcNow, AggregateRootId = copiedAggregateRoot.UniqueId, AggregateRootTypeName = aggregateRootTypeName, Version = copiedAggregateRoot.Version, SerializedPayload = aggregateRootJson, }; var sql = string.Format(InsertOrUpdateSnapshotSql, _snapshotRepository.GetTableName(snapshot.AggregateRootId)); using (var connection = _snapshotRepository.GetConnection()) { await connection.ExecuteAsync(sql, snapshot); } }
public static Dictionary <string, object> Export(DeepCopier copier) { var values = RequestContext.CallContextData.Value; if (RequestContext.PropagateActivityId) { var activityIdOverride = Trace.CorrelationManager.ActivityId; if (activityIdOverride != Guid.Empty) { object existingActivityId; if (values == null || !values.TryGetValue(RequestContext.E2_E_TRACING_ACTIVITY_ID_HEADER, out existingActivityId) || activityIdOverride != (Guid)existingActivityId) { // Create new copy before mutating data values = values == null ? new Dictionary <string, object>() : new Dictionary <string, object>(values); values[RequestContext.E2_E_TRACING_ACTIVITY_ID_HEADER] = activityIdOverride; } } } return((values != null && values.Count > 0) ? copier.Copy(values) : null); }
public MethodInfos() { GetUninitializedObject = GetFuncCall(() => FormatterServices.GetUninitializedObject(typeof(int))); GetTypeFromHandle = GetFuncCall(() => Type.GetTypeFromHandle(typeof(Type).TypeHandle)); CopyInner = GetFuncCall(() => DeepCopier.Copy(default(object), default)).GetGenericMethodDefinition(); TryGetCopy = typeof(DeepCopyContext).GetMethod("TryGetCopy"); RecordObject = GetActionCall((DeepCopyContext ctx) => ctx.RecordCopy(default, default));
public void DeepCopy() { for (var i = 0; i < Count; i++) { DeepCopier.Copy(Price); } }
public void ImmutableWrapperTypesAreNotCopied() { var original = Immutable.Create(new object[] { 123, "hello!" }); var result = DeepCopier.Copy(original); Assert.Same(original.Value, result.Value); }
internal SimpleMessageStreamProducer( StreamImpl <T> stream, string streamProviderName, IStreamProviderRuntime providerUtilities, bool fireAndForgetDelivery, bool optimizeForImmutableData, IStreamPubSub pubSub, IStreamFilter streamFilter, bool isRewindable, DeepCopier <T> deepCopier, ILogger <SimpleMessageStreamProducer <T> > logger) { this.stream = stream; this.streamProviderName = streamProviderName; providerRuntime = providerUtilities; this.pubSub = pubSub; this.streamFilter = streamFilter; this.deepCopier = deepCopier; connectedToRendezvous = false; this.fireAndForgetDelivery = fireAndForgetDelivery; this.optimizeForImmutableData = optimizeForImmutableData; IsRewindable = isRewindable; isDisposed = false; initLock = new AsyncLock(); this.logger = logger; ConnectToRendezvous().Ignore(); }
public void CanCopyStrings() { var original = "hello!"; var result = DeepCopier.Copy(original); Assert.Same(original, result); }
public void CanCopyIntegers() { var original = 123; var result = DeepCopier.Copy(original); Assert.Equal(original, result); }
public static T DeepCopy <T>(T value, DeepCopyOptions options = DeepCopyOptions.DeepCopier) { return(options switch { DeepCopyOptions.DeepCopier => DeepCopier.Copy(value), DeepCopyOptions.ExpressionCopier => ExpressionCopier <T> .Copy(value), _ => ExpressionCopier <T> .Copy(value) });
public SimpleStreamEventDataGenerator(StreamId streamId, ILogger <SimpleStreamEventDataGenerator> logger, DeepCopier deepCopier, Serializer serializer) { this.StreamId = streamId; this.logger = logger; this.ShouldProduce = true; this.deepCopier = deepCopier; this.serializer = serializer; }
public ErrorInjectionStorageProvider( ILogger <ErrorInjectionStorageProvider> logger, ILoggerFactory loggerFactory, DeepCopier copier) : base(loggerFactory, copier) { this.logger = logger; SetErrorInjection(ErrorInjectionBehavior.None); }
public void CanCopyArraysTwoDimensional() { var original = new object[][] { new object[] { 123, "hello!" }, new object[] { 123, "hello!" } }; var result = DeepCopier.Copy(original); Assert.Equal(original, result); Assert.NotSame(original, result); }
public void CanCopyPrimitiveArrays() { var original = new int[] { 1, 2, 3 }; var result = DeepCopier.Copy(original); Assert.Equal(original, result); Assert.NotSame(original, result); }
public void CanCopyMutableKeyValuePair() { var original = new KeyValuePair <string, Poco>("Hello", new Poco()); var result = DeepCopier.Copy(original); Assert.Same(original.Key, result.Key); Assert.NotSame(original.Value, result.Value); }
public INode GetTraversedTree(List <bool> answers) { //Deep Clone Original Data Source. INode node = DeepCopier.Copy(_dataSource.DecisionTree); //node = node.DeepClone(); GetTraversedTree(answers.ToList(), ref node); return(node); }
public void CanCopyMutableValueTupleRest() { var original = new ValueTuple <int, string, double, int, string, double, int, ValueTuple <Poco> >(5, "hello", 1d, 2, "world", 3d, 7, new ValueTuple <Poco>(new Poco())); var result = DeepCopier.Copy(original); Assert.NotEqual(original.Rest, result.Rest); }
public void ReferencesInArraysArePreserved() { var poco = new Poco(); var original = new[] { poco, poco }; var result = DeepCopier.Copy(original); Assert.NotSame(original, result); Assert.Same(result[0], result[1]); }
public MembershipTableSystemTarget( ILocalSiloDetails localSiloDetails, ILoggerFactory loggerFactory, DeepCopier deepCopier) : base(CreateId(localSiloDetails), localSiloDetails.SiloAddress, lowPriority: false, loggerFactory) { logger = loggerFactory.CreateLogger <MembershipTableSystemTarget>(); table = new InMemoryMembershipTable(deepCopier); logger.Info(ErrorCode.MembershipGrainBasedTable1, "GrainBasedMembershipTable Activated."); }
public void ImmutableTypesAreNotCopied() { var original = new ImmutablePoco { Reference = new object[] { 123, "hello!" } }; var result = DeepCopier.Copy(original); Assert.Same(original.Reference, result.Reference); Assert.Same(original, result); }
public void CanCopyPrimitiveArraysRank3() { var original = new int[, , ] { { { 12, 2, 35 }, { 300, 78, 33 } }, { { 92, 42, 135 }, { 30, 7, 3 } } }; var result = DeepCopier.Copy(original); Assert.Equal(original, result); Assert.NotSame(original, result); }
internal static object OrleansSerializationLoop(Serializer serializer, DeepCopier copier, object input, bool includeWire = true) { var copy = copier.Copy(input); if (includeWire) { copy = serializer.RoundTripSerializationForTesting(copy); } return(copy); }
public void CanCopyArraysRank3() { var original = new object[, , ] { { { "Hello", 2, "World" }, { 300.0f, "World", 33 } }, { { 92, 5.0m, 135 }, { 30, true, 3 } } }; var result = DeepCopier.Copy(original); Assert.Equal(original, result); Assert.NotSame(original, result); }
public void RegressionTest_20() { var original = new Dictionary <int, Component>() { { 1, new Component() }, }; var result = DeepCopier.Copy(original); GC.GetTotalMemory(true); // force full GC }
public void CanCopyInterfaceField() { PocoWithInterface original = new PocoWithInterface(); original.Collection.Add("A"); var result = DeepCopier.Copy(original); Assert.NotSame(original, result); Assert.NotSame(original.Collection, result.Collection); }
public TypeWeaver(TypeDefinition originTypeDef, TypeDefinition destinationTypeDef) { this.DestinationType = destinationTypeDef; this.OriginType = originTypeDef; this.NamePrefix = ""; instructions = new List<Instruction>(); referenceMap = new Dictionary<MemberReference,MemberReference>(); constants = new Dictionary<FieldReference, object>(); copier = new DeepCopier(this); }
public void CanCopyCyclicObjects() { var original = new Poco(); original.Reference = original; var result = DeepCopier.Copy(original); Assert.NotSame(original, result); Assert.Same(result, result.Reference); }
public void CanCopyCyclicObjectsWithBaseSibling() { var original = new CyclicPocoWithBaseSibling(); original.BaseSibling = original; var result = DeepCopier.Copy(original); Assert.NotSame(original, result); Assert.Same(result, result.BaseSibling); }
public void CanCopyCyclicObjectsWithChildren() { var original = new CyclicPocoWithChildren(); original.Children.Add(original); var result = DeepCopier.Copy(original); Assert.NotSame(original, result); Assert.Same(result, result.Children[0]); }
public void CanCopyBaseClassField() { PocoWithBaseClass original = new PocoWithBaseClass(new DerivedChildClass()); var result = DeepCopier.Copy(original); Assert.NotSame(original, result); Assert.NotSame(original.Child, result.Child); }
static void Main(string[] args) { log4net.Config.BasicConfigurator.Configure(); var options = new Options(); var parseSuccess = CommandLine.Parser.Default.ParseArguments(args, options); if (parseSuccess) { var appState = new ApplicationState(); var copier = new DeepCopier(); var resxReader = new ResxReader(appState, null); var jsonHelper = new JsonHelper(); var converter = new ResxToJsConverter(copier, resxReader, jsonHelper, appState, null); converter.Convert(options); DisplayErrorMessages(appState); } else { Console.WriteLine("An error occurred while parsing the options."); } ////Console.ReadLine(); }
private void Merge(DeepCopier copier, Collection<Instruction>def1, Collection<Instruction> def2) { //TODO dont override destination instructions always, we migth gona need prepend def2.Clear(); foreach(var i in def1){ def2.Add(copier.Copy(i)); } }
private MethodReturnType Copy(DeepCopier copier, MethodReturnType def, IMethodSignature parent) { var ret= new MethodReturnType(parent); ret.ReturnType = CopyReference(copier,def.ReturnType); copier.Log("< MethodReturnType "); copier.CopyAll(def,ret,ret,"Method","ReturnType"); return ret; }
private void Merge(DeepCopier copier, Collection<CustomAttribute>def1, Collection<CustomAttribute> def2) { }
private void MergeReference(DeepCopier copier, FieldReference @ref1, FieldReference @ref2) { }
private void MergeReference(DeepCopier copier, PropertyReference @ref1, PropertyReference @re2) { }
private void Merge(DeepCopier copier, Collection<MethodReference>def1, Collection<MethodReference> def2) { }
private void Merge(DeepCopier copier, Collection<GenericParameter>def1, Collection<GenericParameter> def2) { }
private void Merge(DeepCopier copier, ParameterDefinition def1, ParameterDefinition def2) { copier.MergeAll(def1,def2,def2,"Name", "Method","ParameterType","MetadataToken", "Module"); }
private void Merge(DeepCopier copier, VariableDefinition def1, VariableDefinition def2) { copier.MergeAll(def1,def2,def2,"VariableType"); }
private void Merge(DeepCopier copier, MethodDefinition def1, MethodDefinition def2) { copier.MergeAll(def1,def2,def2,"Name","DeclaringType","ReturnType","MetadataToken", "Module", "Attributes"); }
private void Merge(DeepCopier copier, TypeDefinition def1, TypeDefinition def2) { copier.MergeAll(def1,def2,def2,"Name","DeclaringType","BaseType","MetadataToken", "Module"); }
private void Merge(DeepCopier copier, PropertyDefinition def1, PropertyDefinition def2) { copier.MergeAll(def1,def2,def2,"Name","DeclaringType","PropertyType","MetadataToken", "Module", "Attributes"); }
private GenericInstanceType CopyReference(DeepCopier copier, GenericInstanceType def) { return CopyReference(copier,def); }
private TypeReference CopyReference(DeepCopier copier, TypeReference @ref) { if(@ref.Scope == OriginType.Scope){ if(copier.CopyMap.ContainsKey(@ref)) return (TypeReference)copier.CopyMap[@ref]; if(referenceMap.ContainsKey(@ref)) return (TypeReference)referenceMap[@ref]; throw new Exception("Cannot find Type "[email protected]+". Try to Copy/Merge/Map it first."); } copier.Log("Importing "[email protected]+ " from "+ @ref.Scope.Name); return DestinationType.Module.Import(@ref); }
private void Merge(DeepCopier copier, Collection<ExceptionHandler>def1, Collection<ExceptionHandler> def2) { }
private void Merge(DeepCopier copier, CustomAttribute def1, CustomAttribute def2) { copier.MergeAll(def1,def2,def2,"DeclaringType"); }
private void Merge(DeepCopier copier, Collection<VariableDefinition>def1, Collection<VariableDefinition> def2) { //TODO dont override destination instructions always def2.Clear(); foreach(var v in def1){ def2.Add(copier.Copy(v)); } }
private void Merge(DeepCopier copier, GenericInstanceType def1, GenericInstanceType def2) { }
private void Merge(DeepCopier copier, Collection<MethodDefinition>def1, Collection<MethodDefinition> def2) { }
private void Merge(DeepCopier copier, Mono.Cecil.Cil.MethodBody def1, Mono.Cecil.Cil.MethodBody def2) { copier.MergeAll(def1,def2,def2,"Method"); }
private void Merge(DeepCopier copier, Collection<ParameterDefinition>def1, Collection<ParameterDefinition> def2) { //check if different }
private void Merge(DeepCopier copier, MethodReturnType def1, MethodReturnType def2) { copier.MergeAll(def1,def2,def2,"Method","ReturnType"); }
private void MergeReference(DeepCopier copier, MethodReference @ref1, MethodReference @re2) { }
/* private void Merge(DeepCopier copier, ExceptionHandler def1, ExceptionHandler def2) { copier.MergeAll(def1,def2,def2,"CatchType"); } private void Merge(DeepCopier copier, Instruction def, Instruction def) { if(!instructions.Contains(def)){ if( def.Operand is MemberReference){ instructions.Add(def); } } return def; } */ private void Merge(DeepCopier copier, Collection<SecurityDeclaration>def1, Collection<SecurityDeclaration> def2) { }
private void MergeReference(DeepCopier copier, TypeReference @ref1, TypeReference @re2) { }
private System.Byte[] Copy(DeepCopier copier, System.Byte[] value) { return value; }
private ExceptionHandler Copy(DeepCopier copier, ExceptionHandler def) { var ret= new ExceptionHandler(def.HandlerType); if(def.CatchType != null) ret.CatchType = CopyReference(copier,def.CatchType); copier.Log("< ExceptionHandler "); copier.CopyAll(def,ret,ret,"CatchType"); return ret; }
private Instruction Copy(DeepCopier copier, Instruction def) { //copy of operands is delayed to ProcessInstructions Instruction ret= null; if(def.Operand == null){ ret = Instruction.Create(def.OpCode); } else { var methodInfo = typeof(Instruction).GetMethod("Create",new Type[]{def.OpCode.GetType(),def.Operand.GetType()}); ret = (Instruction) methodInfo.Invoke(null,new object[]{def.OpCode,def.Operand}); } instructions.Add(ret); return ret; }