protected override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
AbstractSerializer.RegisterKnownType(typeof(MyIdentity));
AbstractSerializer.RegisterKnownType(typeof(MySerializationMessage <MyIdentity>));
Xyperico.Agres.ProtoBuf.SerializerSetup.RegisterInheritance <Identity <TId>, MyIdentity>();
}
private void TestDeserialization <TModel>(TModel model, AbstractSerializer serializer)
{
string serialize = serializer.Serialize(model);
TModel deserialize = serializer.Deserialize <TModel>(serialize);
Console.WriteLine(deserialize);
}
public virtual void WriteObject <T>(string path, Stream stream, T instance, AbstractSerializer serializer)
{
if (serializer is BinarySerializer)
{
WriteYuzuBinarySignature(stream);
}
serializer.ToStream(instance, stream);
}
public void WhenSerializingUnknownTypeItThrowsInvalidOperation()
{
AbstractSerializer.RegisterKnownType(typeof(object));
AbstractSerializer s = new MySerializer();
AssertThrows <InvalidOperationException>(() => s.Serialize(new { }));
}
private static void RegisterInternalSerializableTypes()
{
var serializerTypes =
typeof(BaseConfigurationExtensions).Assembly.GetTypes()
.Where(t => typeof(Identity <>).IsAssignableFrom(t) || typeof(IMessage).IsAssignableFrom(t))
.Where(t => !t.IsAbstract);
AbstractSerializer.RegisterKnownTypes(serializerTypes);
}
/// <summary>
/// Register all serializable types - this is needed for some serializers (ProtoBuf for instance).
/// </summary>
/// <param name="cfg"></param>
/// <param name="types"></param>
/// <returns></returns>
public static BaseConfiguration SerializableTypes(this BaseConfiguration cfg, IEnumerable <Type> types)
{
Condition.Requires(cfg, "cfg").IsNotNull();
Condition.Requires(types, "types").IsNotNull();
AbstractSerializer.RegisterKnownTypes(types);
RegisterInternalSerializableTypes();
return(cfg);
}
public static void Main(string[] args)
{
AbstractSerializer.RegisterKnownType(typeof(UserCreatedEvent));
// Create serializers after registering known types
ISerializer[] Serializers =
{
new DataContractSerializer(),
new ProtoBufSerializer(),
new BsonNetSerializer(),
new JsonNetSerializer()
};
foreach (Func <IAppendOnlyStore> aStoreBuilder in AppendOnlyStores)
{
foreach (ISerializer serializer in Serializers)
{
UserId id = new UserId(1);
List <IEvent> events = new List <IEvent>()
{
new UserCreatedEvent(id, "John")
};
IAppendOnlyStore aStore = aStoreBuilder();
try
{
EventStoreDB eStore = new EventStoreDB(aStore, serializer);
eStore.Append(id, 0, events);
// Warm up various caches
for (int i = 0; i < 10; ++i)
{
EventStream s = eStore.Load(id);
eStore.Append(id, s.Version, events);
}
int count = 0;
DateTime t1 = DateTime.Now;
do
{
id = new UserId(100 + count);
//EventStream s = eStore.Load(id);
eStore.Append(id, 0, new IEvent[] { new UserCreatedEvent(id, "John") });
++count;
}while ((DateTime.Now - t1) < TimeSpan.FromMilliseconds(1000));
Console.WriteLine("{0} + {1}: {2}", aStore, serializer, count);
}
finally
{
aStore.Dispose();
}
}
}
}
public override void WriteObject <T>(string path, Stream stream, T instance, AbstractSerializer serializer)
{
pathStack.Push(path);
PushCurrent(this);
try {
base.WriteObject <T>(path, stream, instance, serializer);
} finally {
pathStack.Pop();
PopCurrent();
}
}
/// <summary>
/// Добавляет сериализатор.
/// </summary>
/// <param name="serializer">Сериализатор.</param>
/// <param name="throwOnExists">Бросать исключение, если сериализатор для типа уже существует.
/// В противном случае, заменяет на новый сериализатор.</param>
public void AddSerializer(AbstractSerializer serializer, bool throwOnExists = true)
{
if (!IsExists(serializer.SerializerType) || !throwOnExists)
{
_serializers.Add(serializer);
}
else
{
throw new SerializerAlreadyExistsException(serializer.SerializerType);
}
}
/// <summary>
/// Writes any object to the output stream.
/// </summary>
/// <param name="obj">object to write</param>
public override void WriteObject(object obj)
{
if (obj == null)
{
WriteNull();
return;
}
AbstractSerializer abstractSerializer = m_serializerFactory.GetSerializer(obj.GetType());
abstractSerializer.WriteObject(obj, this);
}
public static void WriteObject <T>(string path, Stream stream, T instance, AbstractSerializer serializer)
{
SerializationPathStack.Push(path);
try {
if (serializer is BinarySerializer)
{
WriteYuzuBinarySignature(stream);
}
serializer.ToStream(instance, stream);
} finally {
SerializationPathStack.Pop();
}
}
public void SaveGame(string fileName, List <AbstractFigure> figuresOnDesk)
{
string fileExtention = this.GetFileExtention(fileName);
try
{
this.serializer = this.CreateSerializerByExtention(fileExtention);
this.serializer.SaveFiles(fileName, figuresOnDesk);
}
catch (Exception e) // Need to complete this
{
throw e;
}
}
public static void Initialize()
{
Xyperico.Agres.ProtoBuf.SerializerSetup.RegisterInheritance <Identity <Guid>, UserAccountId>();
var serializerTypes =
typeof(UserAccountId).Assembly.GetTypes()
.Where(t => typeof(Identity <>).IsAssignableFrom(t) || typeof(IMessage).IsAssignableFrom(t))
.Where(t => !t.IsAbstract);
AbstractSerializer.RegisterKnownTypes(serializerTypes);
AbstractSerializer.RegisterKnownType(typeof(EMail));
AbstractSerializer.RegisterKnownType(typeof(UserAccountId));
AbstractSerializer.RegisterKnownType(typeof(UserAccountCreatedEvent));
AbstractSerializer.RegisterKnownType(typeof(PasswordChangedEvent));
}
public IEnumerable <AbstractFigure> GetSaveGame(string fileName)
{
IEnumerable <AbstractFigure> loadGame;
string fileExtension = this.GetFileExtention(fileName);
try
{
this.serializer = this.CreateSerializerByExtention(fileExtension);
loadGame = this.serializer.OpenFiles(fileName);
return(loadGame);
}
catch (Exception e) // Need to complete this
{
throw e;
}
}
public static void WriteObject <T>(string path, Stream stream, T instance, AbstractSerializer serializer) => Yuzu.Instance.Value.WriteObject(path, stream, instance, serializer);
