private static object Copy(object input, ICopyContext context)
{
CopyCounter++;
var obj = input as ClassWithCustomCopier;
return(new ClassWithCustomCopier()
{
IntProperty = obj.IntProperty, StringProperty = obj.StringProperty
});
}
public object DeepCopy(object source, ICopyContext context)
{
if (source == null)
{
return(null);
}
dynamic dynamicSource = source;
return(dynamicSource.Clone());
}
public static object DeepCopier(object original, ICopyContext context)
{
AdvancedPOCO instance = (AdvancedPOCO)original;
int a = (int)SerializationManager.DeepCopyInner(instance.A, context);
int b = (int)SerializationManager.DeepCopyInner(instance.B, context);
return(new AdvancedPOCO {
A = a, B = b
});
}
internal static object DeepCopier(object original, ICopyContext context)
{
GrainStateWithMetaDataAndETag <TView> instance = (GrainStateWithMetaDataAndETag <TView>)original;
string etag = (string)SerializationManager.DeepCopyInner(instance.ETag, context);
TView state = (TView)SerializationManager.DeepCopyInner(instance.State, context);
int globalVersion = (int)SerializationManager.DeepCopyInner(instance.GlobalVersion, context);
string writeVector = (string)SerializationManager.DeepCopyInner(instance.WriteVector, context);
return(new GrainStateWithMetaDataAndETag <TView>(etag, state, globalVersion, writeVector));
}
static private object Copy(object input, ICopyContext context)
{
var inputCopy = context.CheckObjectWhileCopying(input);
if (inputCopy == null)
{
context.RecordCopy(input, inputCopy);
}
var copy = SerializationManager.DeepCopyInner(input, context);
return(copy);
}
public virtual object DeepCopy(object source, ICopyContext context)
{
using (var toStream = new MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(toStream, source);
toStream.Position = 0;
var obTarget = formatter.Deserialize(toStream);
toStream.Close();
return(obTarget);
}
}
/// <inheritdoc />
public object DeepCopy(object source, ICopyContext context)
{
var type = source.GetType();
if (type.IsValueType)
{
var serializer = _valueTypeSerializerFactory.GetSerializer(type);
return(serializer.DeepCopy(source, context));
}
return(_objectSerializer.DeepCopy(source, context));
}
public static object DeepCopier(object original, ICopyContext context)
{
var input = (IDictionary <string, object>)original;
var result = new ActivityContext();
foreach (var kvp in input)
{
result.Data.Add(kvp.Key, kvp.Value);
}
context.RecordCopy(original, result);
return(result);
}
public static object DeepCopier(object original, ICopyContext context)
{
ReportingPOCO instance = (ReportingPOCO)original;
int a = (int)SerializationManager.DeepCopyInner(instance.A, context);
int b = (int)SerializationManager.DeepCopyInner(instance.B, context);
int copyCount = (int)SerializationManager.DeepCopyInner(instance.CopyCount, context);
int serializeCount = (int)SerializationManager.DeepCopyInner(instance.SerializeCount, context);
int deserializeCount = (int)SerializationManager.DeepCopyInner(instance.DeserializeCount, context);
return(new ReportingPOCO {
A = a, B = b, CopyCount = copyCount + 1, SerializeCount = serializeCount, DeserializeCount = deserializeCount
});
}
/// <summary>
/// Create a deep copy of the token.
/// </summary>
/// <param name="original">The token to copy</param>
/// <param name="context">The serialization context.</param>
/// <returns>A copy</returns>
public static object DeepCopy(object original, ICopyContext context)
{
var source = original as EventHubSequenceTokenV2;
if (source == null)
{
return(null);
}
var copy = new EventHubSequenceTokenV2(source.EventHubOffset, source.SequenceNumber, source.EventIndex);
context.RecordCopy(original, copy);
return(copy);
}
public object DeepCopy(object source, ICopyContext context)
{
if (source == null)
{
return(null);
}
using (var stream = new MemoryStream())
{
copier.Serialize(source, stream);
stream.Position = 0;
return(copier.Deserialize(stream));
}
}
/// <inheritdoc />
public object DeepCopy(object source, ICopyContext context)
{
if (source == null)
{
return null;
}
var clonerInfo = GetClonerInfo(source.GetType().TypeHandle);
if (clonerInfo == null)
{
LogWarning(1, "no copier found for type {0}", source.GetType());
throw new ArgumentOutOfRangeException("original", "no copier provided for the selected type");
}
return clonerInfo.Invoke(source);
}
public static object DeepCopier(object original, ICopyContext context)
{
var input = (User)original;
var result = new User();
// Record 'result' as a copy of 'input'. Doing this immediately after construction allows for
// data structures which have cyclic references or duplicate references.
// For example, imagine that 'input.BestFriend' is set to 'input'. In that case, failing to record
// the copy before trying to copy the 'BestFriend' field would result in infinite recursion.
context.RecordCopy(original, result);
// Deep-copy each of the fields.
result.BestFriend = (User)SerializationManager.DeepCopyInner(input.BestFriend, context);
result.NickName = input.NickName; // strings in .NET are immutable, so they can be shallow-copied.
result.FavoriteNumber = input.FavoriteNumber; // ints are primitive value types, so they can be shallow-copied.
result.BirthDate = (DateTimeOffset)SerializationManager.DeepCopyInner(input.BirthDate, context);
return(result);
}
public object DeepCopy(object source, ICopyContext context)
{
if (source == null)
{
return(null);
}
var formatter = new BinaryFormatter();
object ret = null;
using (var memoryStream = new MemoryStream())
{
formatter.Serialize(memoryStream, source);
memoryStream.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
formatter.Binder = DynamicBinder.Instance;
ret = formatter.Deserialize(memoryStream);
}
return(ret);
}
/// <inheritdoc />
public object DeepCopy(object source, ICopyContext context)
{
var type = source.GetType();
var callbacks = _serializationCallbacks.GetReferenceTypeCallbacks(type);
var serializable = (ISerializable)source;
var result = FormatterServices.GetUninitializedObject(type);
context.RecordCopy(source, result);
// Shallow-copy the object into the serialization info.
var originalInfo = new SerializationInfo(type, _formatterConverter);
var streamingContext = new StreamingContext(StreamingContextStates.All, context);
callbacks.OnSerializing?.Invoke(source, streamingContext);
serializable.GetObjectData(originalInfo, streamingContext);
// Deep-copy the serialization info.
var copyInfo = new SerializationInfo(type, _formatterConverter);
foreach (var item in originalInfo)
{
copyInfo.AddValue(item.Name, SerializationManager.DeepCopyInner(item.Value, context));
}
callbacks.OnSerialized?.Invoke(source, streamingContext);
callbacks.OnDeserializing?.Invoke(result, streamingContext);
// Shallow-copy the serialization info into the result.
var constructor = _constructorFactory.GetSerializationConstructorDelegate(type);
constructor(result, copyInfo, streamingContext);
callbacks.OnDeserialized?.Invoke(result, streamingContext);
if (result is IDeserializationCallback callback)
{
callback.OnDeserialization(context);
}
return(result);
}
/// <inheritdoc />
public object DeepCopy(object source, ICopyContext context)
{
if (source == null)
{
return(null);
}
var serializationContext = new SerializationContext(context.GrainFactory)
{
StreamWriter = new BinaryTokenStreamWriter()
};
Serialize(source, serializationContext, source.GetType());
var deserializationContext = new DeserializationContext(context.GrainFactory)
{
StreamReader = new BinaryTokenStreamReader(serializationContext.StreamWriter.ToBytes())
};
var retVal = Deserialize(source.GetType(), deserializationContext);
serializationContext.StreamWriter.ReleaseBuffers();
return(retVal);
}
/// <inheritdoc />
public object DeepCopy(object source, ICopyContext context)
{
if (source == null)
{
return null;
}
var outputWriter = new BinaryTokenStreamWriter();
var serializationContext = new SerializationContext(context.GetSerializationManager())
{
StreamWriter = outputWriter
};
Serialize(source, serializationContext, source.GetType());
var deserializationContext = new DeserializationContext(context.GetSerializationManager())
{
StreamReader = new BinaryTokenStreamReader(outputWriter.ToBytes())
};
var retVal = Deserialize(source.GetType(), deserializationContext);
outputWriter.ReleaseBuffers();
return retVal;
}
private static object Copy(object input, ICopyContext context)
{
CopyWasCalled = true;
return(input);
}
public object DeepCopy(object source, ICopyContext context)
{
DeepCopyCalled = true;
return(source);
}
public static object DeepCopier(object original, ICopyContext context)
{
return(original);
}
static object Copy(object input, ICopyContext context) => input;
public static object DeepCopier(object original, ICopyContext context)
{
// I assume JObject is immutable, so no need to deep copy.
// Alternatively, can copy via JObject.ToString and JObject.Parse().
return(original);
}
/// <inheritdoc /> public object DeepCopy(object source, ICopyContext context) => this.serializer.DeepCopy(source, context);
public object DeepCopy(object source, ICopyContext context)
{
return(source);
}
public object DeepCopy(object source, ICopyContext context)
{
throw new NotSupportedException();
}
protected internal static object CopyGrainReference(object original, ICopyContext context)
{
return((GrainReference)original);
}
internal static object CopyGrainCancellationToken(object obj, ICopyContext context)
{
var gct = (GrainCancellationToken)obj;
return(new GrainCancellationToken(gct.Id, gct.IsCancellationRequested));
}
public object DeepCopy(object source, ICopyContext context)
{
var fooCopy = SerializationManager.DeepCopyInner(source, context);
throw new NotImplementedException();
}
public static object DeepCopier(object original, ICopyContext context)
{
return(new XDocument((XDocument)original));
}
public static object DeepCopy(object original, ICopyContext context)
{
var typed = (UndeserializableType)original;
return(new UndeserializableType(typed.Number));
}