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;
}
