public void CanSerializeWithInterfaceSurrogate() { var surrogateHasBeenInvoked = false; var surrogates = new[] { Surrogate.Create <IOriginal, ISurrogate>(from => from.ToSurrogate(), surrogate => { surrogateHasBeenInvoked = true; return(surrogate.FromSurrogate()); }) }; var stream = new MemoryStream(); var serializer = new Serializer(new SerializerOptions(surrogates: surrogates)); var foo = new Foo { Bar = "I will be replaced!" }; serializer.Serialize(foo, stream); stream.Position = 0; var actual = serializer.Deserialize <Foo>(stream); Assert.AreEqual(foo.Bar, actual.Bar); Assert.IsTrue(surrogateHasBeenInvoked); }
public void CanSerializeWithSurrogate() { var surrogateHasBeenInvoked = false; var surrogates = new[] { Surrogate.Create <Foo, FooSurrogate>(FooSurrogate.FromFoo, surrogate => { surrogateHasBeenInvoked = true; return(surrogate.Restore()); }) }; var stream = new MemoryStream(); var serializer = new Serializer(new SerializerOptions(surrogates: surrogates)); var foo = new Foo { Bar = "I will be replaced!" }; serializer.Serialize(foo, stream); stream.Position = 0; var actual = serializer.Deserialize <Foo>(stream); Assert.Equal(foo.Bar, actual.Bar); Assert.True(surrogateHasBeenInvoked); }
public void Initialize(Logger logger) { var surogates = new[] { Surrogate.Create <ActorPath, ActorPathSurrogate>(ActorPathSurrogate.From, x => x.Original()), Surrogate.Create <StreamPath, StreamPathSurrogate>(StreamPathSurrogate.From, x => x.Original()), Surrogate.Create <ActorRef, ActorRefSurrogate>(ActorRefSurrogate.From, x => x.Original(this)), Surrogate.Create <StreamRef, StreamRefSurrogate>(StreamRefSurrogate.From, x => x.Original(this)), Surrogate.Create <ClientRef, ClientRefSurrogate>(ClientRefSurrogate.From, x => x.Original(this)), }; var options = new SerializerOptions( versionTolerance: true, preserveObjectReferences: true, surrogates: surogates); serializer = new Hyperion.Serializer(options); options = new SerializerOptions( versionTolerance: false, preserveObjectReferences: true, surrogates: surogates); copier = new Hyperion.Serializer(options); }
public void Issue263_CanSerializeArrayOfSurrogate_WhenPreservingObjectReference() { var invoked = new List <SurrogatedClass.ClassSurrogate>(); var serializer = new Serializer(new SerializerOptions( preserveObjectReferences: true, surrogates: new [] { Surrogate.Create <SurrogatedClass, SurrogatedClass.ClassSurrogate>( to => to.ToSurrogate(), from => { invoked.Add(from); return(from.FromSurrogate()); }), })); var objectRef = new SurrogatedClass(5); var expected = new List <SurrogatedClass> { objectRef, objectRef }; using (var stream = new MemoryStream()) { serializer.Serialize(expected, stream); stream.Position = 0; var deserialized = serializer.Deserialize <List <SurrogatedClass> >(stream); deserialized.Count.Should().Be(2); invoked.Count.Should().Be(1); ReferenceEquals(deserialized[0], deserialized[1]).Should().BeTrue(); } }
public void CanSerializeWithSurrogateInCollection() { var invoked = new List <ISurrogate>(); var surrogates = new[] { Surrogate.Create <IOriginal, ISurrogate>(from => from.ToSurrogate(), surrogate => { invoked.Add(surrogate); return(surrogate.FromSurrogate()); }) }; var stream = new MemoryStream(); var serializer = new Serializer(new SerializerOptions(surrogates: surrogates)); var key = new SurrogatedKey("test key"); var foo = new Foo { Bar = "I will be replaced!" }; var dictionary = new Dictionary <SurrogatedKey, Foo> { [key] = foo }; serializer.Serialize(dictionary, stream); stream.Position = 0; var actual = serializer.Deserialize <Dictionary <SurrogatedKey, Foo> > (stream); Assert.Equal(key, actual.Keys.First()); Assert.Equal(foo.Bar, actual[key].Bar); Assert.Equal(2, invoked.Count); }
/// <summary> /// Initializes a new instance of the <see cref="HyperionSerializer"/> class. /// </summary> /// <param name="system">The actor system to associate with this serializer.</param> /// <param name="settings">Serializer settings.</param> public HyperionSerializer(ExtendedActorSystem system, HyperionSerializerSettings settings) : base(system) { Settings = settings; var akkaSurrogate = Surrogate .Create <ISurrogated, ISurrogate>( from => from.ToSurrogate(system), to => to.FromSurrogate(system)); var provider = CreateKnownTypesProvider(system, settings.KnownTypesProvider); if (system != null) { var settingsSetup = system.Settings.Setup.Get <HyperionSerializerSetup>() .GetOrElse(HyperionSerializerSetup.Empty); settingsSetup.ApplySettings(Settings); } _serializer = new HySerializer(new SerializerOptions( versionTolerance: settings.VersionTolerance, preserveObjectReferences: settings.PreserveObjectReferences, surrogates: new[] { akkaSurrogate }, serializerFactories: null, knownTypes: provider.GetKnownTypes(), ignoreISerializable: true, packageNameOverrides: settings.PackageNameOverrides)); }
public TestMessageFormatter() : base( new SerializerOptions( versionTolerance: false, preserveObjectReferences: true, surrogates: new[] { Surrogate.Create <ITestMessage, TestMessageSurrogate>(TestMessageSurrogate.ToSurrogate, TestMessageSurrogate.FromSurrogate), } )) { }
public ClunkerApp(ResourceLoader resourceLoader, Scene initialScene) { Resources = resourceLoader; Serializer = new Serializer(new SerializerOptions(true, true, new[] { Surrogate.Create <Resource <Image <Rgba32> >, ResourceSurrogate <Image <Rgba32> > >(r => new ResourceSurrogate <Image <Rgba32> >() { Id = r.Id }, s => resourceLoader.LoadImage(s.Id)) })); NextScene = initialScene; _renderers = new List <IRenderer>(); WorkQueue = new RoundRobinWorkQueue(new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue()); BestEffortFrameQueue = new DrivenWorkQueue(); }
/// <summary> /// Initializes a new instance of the <see cref="WireSerializer"/> class. /// </summary> /// <param name="system">The actor system to associate with this serializer.</param> public WireSerializer(ExtendedActorSystem system) : base(system) { var akkaSurrogate = Surrogate .Create <ISurrogated, ISurrogate>( from => from.ToSurrogate(system), to => to.FromSurrogate(system)); _serializer = new Hyperion.Serializer(new SerializerOptions( preserveObjectReferences: true, versionTolerance: true, surrogates: new[] { akkaSurrogate })); }
/// <summary> /// Initializes a new instance of the <see cref="HyperionSerializer"/> class. /// </summary> /// <param name="system">The actor system to associate with this serializer.</param> /// <param name="settings">Serializer settings.</param> public HyperionSerializer(ExtendedActorSystem system, HyperionSerializerSettings settings) : base(system) { this.Settings = settings; var akkaSurrogate = Surrogate .Create <ISurrogated, ISurrogate>( from => from.ToSurrogate(system), to => to.FromSurrogate(system)); var provider = CreateKnownTypesProvider(system, settings.KnownTypesProvider); _serializer = new Hyperion.Serializer(new SerializerOptions( preserveObjectReferences: settings.PreserveObjectReferences, versionTolerance: settings.VersionTolerance, surrogates: new[] { akkaSurrogate }, knownTypes: provider.GetKnownTypes())); }
public void Setup_surrogate_should_work() { var surrogated = new List <Foo>(); var setup = HyperionSerializerSetup.Empty .WithSurrogates(new [] { Surrogate.Create <Foo, FooSurrogate>( foo => { surrogated.Add(foo); return(new FooSurrogate(foo.Bar + ".")); }, surrogate => new Foo(surrogate.Bar)) }); var settings = setup.ApplySettings(HyperionSerializerSettings.Default); var serializer = new HyperionSerializer((ExtendedActorSystem)Sys, settings); var expected = new Foo("bar"); var serialized = serializer.ToBinary(expected); var deserialized = serializer.FromBinary <Foo>(serialized); deserialized.Bar.Should().Be("bar."); surrogated.Count.Should().Be(1); surrogated[0].Should().BeEquivalentTo(expected); }