private void AssertUserModel(CompositeType compositeType)
{
Assert.IsNotNull(compositeType);
Assert.AreEqual("Test.UserModel", compositeType.Name);
Assert.AreEqual(typeof(UserModel), compositeType.Type);
Assert.IsNotNull(compositeType.VersionProperty);
Assert.IsNull(compositeType.VersionProperty.Setter);
Assert.AreEqual(2, compositeType.Versions.Count());
IEnumerator <CompositeVersion> versionEnumerator = compositeType.Versions.GetEnumerator();
Assert.AreEqual(true, versionEnumerator.MoveNext());
CompositeVersion version = versionEnumerator.Current;
Assert.AreEqual(1, version.Version);
Assert.AreEqual(2, version.Properties.Count());
Assert.AreEqual(true, versionEnumerator.MoveNext());
version = versionEnumerator.Current;
Assert.AreEqual(2, version.Version);
Assert.AreEqual(3, version.Properties.Count());
}
private CompositeVersion GetCompositeVersion(CompositeType type, int version, Type inputType)
{
CompositeVersion typeVersion = type.Versions.FirstOrDefault(v => v.Version == version);
if (typeVersion == null)
{
throw new MissingVersionException(inputType, version);
}
return(typeVersion);
}
private void AssertSingleVersion(CompositeType compositeType)
{
Assert.IsNotNull(compositeType);
Assert.AreEqual(typeof(SingleVersion), compositeType.Type);
Assert.AreEqual(1, compositeType.Versions.Count());
IEnumerator <CompositeVersion> versionEnumerator = compositeType.Versions.GetEnumerator();
Assert.AreEqual(true, versionEnumerator.MoveNext());
CompositeVersion version = versionEnumerator.Current;
Assert.AreEqual(1, version.Version);
Assert.AreEqual(1, version.Properties.Count());
}
public bool TrySerialize(object input, ISerializerContext context)
{
CompositeType type;
if (!provider.TryGet(context.InputType, out type))
{
return(false);
}
int version = (int)type.VersionProperty.Getter(input);
CompositeVersion typeVersion = GetCompositeVersion(type, version, context.InputType);
ICompositeStorage storage = storageFactory.Create();
bool result = TryStore(input, context, type, typeVersion, storage);
storage.Store(context.Output);
return(result);
}
public void Reflection_SingleModel()
{
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory(), BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
CompositeType compositeType;
Assert.AreEqual(true, provider.TryGet(typeof(SingleModel), out compositeType));
Assert.AreEqual(typeof(SingleModel), compositeType.Type);
Assert.AreEqual(1, compositeType.Versions.Count());
IEnumerator <CompositeVersion> versionEnumerator = compositeType.Versions.GetEnumerator();
Assert.AreEqual(true, versionEnumerator.MoveNext());
CompositeVersion version = versionEnumerator.Current;
Assert.AreEqual(1, version.Version);
Assert.AreEqual(1, version.Properties.Count());
}
public Task <bool> TrySerializeAsync(object input, ISerializerContext context)
{
CompositeType type;
if (!provider.TryGet(context.InputType, out type))
{
return(Task.FromResult(false));
}
int version = (int)type.VersionProperty.Getter(input);
CompositeVersion typeVersion = GetCompositeVersion(type, version, context.InputType);
ICompositeStorage storage = storageFactory.Create();
bool result = TryStore(input, context, type, typeVersion, storage);
Task task = storage.StoreAsync(context.Output);
task.ConfigureAwait(false);
return(Task <bool> .Factory.ContinueWhenAll(new Task[] { task }, t => result));
}
/// <summary>
/// Tries to load a object from the <paramref name="input"/> described by the <paramref name="type"/>.
/// </summary>
/// <param name="input">The serialized value to deserialize.</param>
/// <param name="context">The deserialization context.</param>
/// <param name="type">The composite type descriptor to load.</param>
/// <param name="storage">The composite storage with loaded values.</param>
/// <returns><c>true</c> if object was deserialized; <c>false</c> otherwise.</returns>
protected virtual bool TryLoad(Stream input, IDeserializerContext context, CompositeType type, ICompositeStorage storage)
{
int version;
if (!storage.TryGet(Name.Version, out version))
{
throw new MissingVersionValueException();
}
CompositeVersion typeVersion = GetCompositeVersion(type, version, context.OutputType);
ICompositeStorage valueStorage;
if (!storage.TryGet(Name.Payload, out valueStorage))
{
throw new MissingPayloadValueException();
}
List <object> values = new List <object>();
foreach (CompositeProperty property in typeVersion.Properties)
{
object value;
if (!TryLoadValue(valueStorage, property.Name, property.Type, out value))
{
throw new NotSupportedValueException(type.Type, property.Name, property.Type);
}
values.Add(value);
}
context.Output = typeVersion.Constructor.Factory(values.ToArray());
if (type.VersionProperty.Setter != null)
{
type.VersionProperty.Setter(context.Output, version);
}
return(true);
}
public void Reflection_TwoVersionWithFirstImplied()
{
ReflectionCompositeTypeProvider provider = new ReflectionCompositeTypeProvider(new ReflectionCompositeDelegateFactory());
CompositeType compositeType;
Assert.AreEqual(true, provider.TryGet(typeof(TwoVersionWithFirstImplied), out compositeType));
Assert.AreEqual(typeof(TwoVersionWithFirstImplied), compositeType.Type);
Assert.AreEqual(2, compositeType.Versions.Count());
IEnumerator <CompositeVersion> versionEnumerator = compositeType.Versions.GetEnumerator();
Assert.AreEqual(true, versionEnumerator.MoveNext());
CompositeVersion version = versionEnumerator.Current;
Assert.AreEqual(1, version.Version);
Assert.AreEqual(1, version.Properties.Count());
Assert.AreEqual(true, versionEnumerator.MoveNext());
version = versionEnumerator.Current;
Assert.AreEqual(2, version.Version);
Assert.AreEqual(2, version.Properties.Count());
}
protected override bool TryStore(object input, ISerializerContext context, CompositeType type, CompositeVersion typeVersion, ICompositeStorage storage)
{
if (input is IList list)
{
storage.Add("Count", list.Count);
for (int i = 0; i < list.Count; i++)
{
object item = list[i];
ICompositeStorage innerStorage = storage.Add(i.ToString());
if (!base.TryStore(item, context, type, typeVersion, innerStorage))
{
return(false);
}
}
return(true);
}
return(base.TryStore(input, context, type, typeVersion, storage));
}
protected override bool TryStore(object input, ISerializerContext context, CompositeType type, CompositeVersion typeVersion, ICompositeStorage storage)
{
if (!base.TryStore(input, context, type, typeVersion, storage))
{
return(false);
}
ICompositeStorage payloadStorage;
GuidedObject guided = input as GuidedObject;
if (guided != null && storage.TryGet(Name.Payload, out payloadStorage))
{
payloadStorage.Add("Guid", guided.Guid);
}
return(true);
}
/// <summary>
/// Tries to store the <paramref name="input"/> to the <paramref name="context"/>. The <paramref name="input"/> is described by the <paramref name="type"/>
/// and in the <paramref name="typeVersion"/>.
/// </summary>
/// <param name="input">The object to store.</param>
/// <param name="context">The serialization context.</param>
/// <param name="type">The <paramref name="input"/> composite type descriptor.</param>
/// <param name="typeVersion">The version of the <paramref name="input"/>.</param>
/// <param name="storage">The composite storage to store values to.</param>
/// <returns><c>true</c> if the <paramref name="input"/> was serialized to the <paramref name="context"/>; <c>false</c> otherwise.</returns>
protected virtual bool TryStore(object input, ISerializerContext context, CompositeType type, CompositeVersion typeVersion, ICompositeStorage storage)
{
storage.Add(Name.TypeName, type.Name);
storage.Add(Name.Version, type.VersionProperty.Getter(input));
ICompositeStorage valueStorage = storage.Add(Name.Payload);
foreach (CompositeProperty property in typeVersion.Properties)
{
object propertyValue = property.Getter(input);
if (!TryStoreValue(valueStorage, property.Name, propertyValue))
{
throw new NotSupportedValueException(type.Type, property.Name, property.Type, propertyValue);
}
}
return(true);
}
protected override bool TryStore(object input, ISerializerContext context, CompositeType type, CompositeVersion typeVersion, ICompositeStorage storage)
{
if (base.TryStore(input, context, type, typeVersion, storage))
{
TryStore(GetOrAddPayloadStorage(storage), input);
IReadOnlyKeyValueCollection metadata;
if (context.TryGetEnvelopeMetadata(out metadata))
{
ICompositeStorage metadataStorage = storage.Add(MetadataKey);
foreach (string key in metadata.Keys)
{
metadataStorage.Add(key, metadata.Get <object>(key));
}
}
return(true);
}
return(false);
}
protected override bool TryStore(object input, ISerializerContext context, CompositeType type, CompositeVersion typeVersion, ICompositeStorage storage)
{
if (base.TryStore(input, context, type, typeVersion, storage))
{
if (input is AggregateRootException e)
{
ICompositeStorage inner = storage.Add(Name.InnerStorage);
inner.Add(Name.AggregateRootKey, e.Key);
inner.Add(Name.CommandKey, e.CommandKey);
inner.Add(Name.SourceCommandKey, e.SourceCommandKey);
}
return(true);
}
return(false);
}
