public static T Clone <T>(
this T source,
CloneMode mode = CloneMode.Bson)
where T : class
{
if (EqualityComparer <T> .Default.Equals(source, default))
{
return(default);
public ICloneStrategy GetCloneStrategy(CloneMode mode)
{
if (!Strategies.TryGetValue(mode, out var strategy))
{
throw new NotSupportedException($"Unknown strategy for mode {mode}");
}
return(strategy);
}
public async Task <bool> CloneAsync(CloneMode mode)
{
await SourceRepository.EnsureApiAvailableAsync(_initialPingInterval, _initialPingTries);
await DestRepository.EnsureApiAvailableAsync(_initialPingInterval, _initialPingTries);
var strategy = _strategyProvider.GetCloneStrategy(mode);
return(await strategy.ExecuteAsync());
}
/// <summary>
/// Attempt to perform a clone of an object, with differing modes of cloning.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="cloneMode"></param>
/// <param name="swallowErrors"></param>
/// <returns></returns>
public static T Clone <T>(T source, CloneMode cloneMode = CloneMode.Deep, bool swallowErrors = true)
{
// if not supposed to clone, just return the original item
if (cloneMode == CloneMode.None)
{
return(source);
}
T clone;
// if the model is cloneable then we try and clone it
if (source is ICloneable cloneableModel)
{
clone = (T)cloneableModel.Clone();
}
else
{
// right, we try and clone the object, this may or may not work...
try
{
clone = cloneMode switch
{
CloneMode.Deep => source.GetClone(),
CloneMode.Shallow => source.GetClone(CloningFlags.Shallow),
_ => source
};
}
catch (Exception exception)
{
if (swallowErrors)
{
Logging.Instance.LogWarning(exception, "Object {model} failed to clone", source);
}
else
{
Logging.Instance.LogError(exception, "Object {model} failed to clone", source);
throw;
}
clone = source;
}
}
return(clone);
}
/// <summary>
/// 对象克隆
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="objSource"></param>
/// <param name="useMode"></param>
/// <returns></returns>
public static T CloneTo <T>(T objSource, CloneMode useMode = CloneMode.Default)
{
using (var ms = new MemoryStream())
{
if (CloneMode.Default == useMode)
{
var formatter = new BinaryFormatter();
formatter.Serialize(ms, objSource);
ms.Seek(0, SeekOrigin.Begin);
return((T)formatter.Deserialize(ms));
}
else if (CloneMode.XMLMode == useMode)
{
var serializer = new XmlSerializer(typeof(T));
serializer.Serialize(ms, objSource);
ms.Seek(0, SeekOrigin.Begin);
return((T)serializer.Deserialize(ms));
}
return(default);
public MemberMapping CloneMode(CloneMode clonemode = NetClone.CloneMode.Default)
{
Mode = clonemode;
return this;
}
public MemberMapping <TSource, TMember> CloneMode(CloneMode clonemode = NetClone.CloneMode.Default)
{
Mode = clonemode;
return(this);
}
/// <summary>
/// Decorate a member with the <see cref="ReferenceCloneAttribute"/> to alter the cloning behavior
/// </summary>
public ReferenceCloneAttribute(CloneMode mode)
{
Mode = mode;
}
/// <summary>
/// Create an instance of the build owner
/// </summary>
/// <param name="cloneMode">They way in which models of stateful containers are stored.</param>
/// <param name="swallowCloneErrors">Whether we should ignore cloning of model errors</param>
/// <remarks>Currently clone mode is only used for indication as to whether to clone at all or not.
/// </remarks>
public BuildOwner(CloneMode cloneMode = CloneMode.Deep, bool swallowCloneErrors = true)
{
_cloneMode = cloneMode;
_swallowCloneErrors = swallowCloneErrors;
ModelBag = new ModelBag();
}
