public void CheckAssemblyNameAfterDeserialization() { ser.Serialize(dtg); AssemblyDTG tmp = ser.Deserialize(); Assert.AreEqual(tmp.Name, "TPA.ApplicationArchitecture.dll"); }
public void Publish(object o) { var route = _routes.OutboundEvents.Single(c => c.MessageType == o.GetType()); var task = _outbound.ProduceAsync(route.Name, null, _encoding.GetString(_serializer.Serialize(o))); task.RunSynchronously(); var result = task.Result; }
public string[] Persist <TFormat>( ISerialization <TFormat> serializer, IServiceProvider locator, TFormat toInsert, TFormat toUpdate, TFormat toDelete) { var repository = locator.Resolve <IPersistableRepository <TRoot> >(); var insertData = toInsert != null?serializer.Deserialize <TFormat, TRoot[]>(toInsert, locator) : null; var updateData = toUpdate != null?serializer.Deserialize <TFormat, KeyValuePair <TRoot, TRoot>[]>(toUpdate, locator) : null; //TODO support old update format if (toUpdate != null && updateData != null && updateData.Length == 0) { var updateValues = serializer.Deserialize <TFormat, TRoot[]>(toUpdate, locator); if (updateValues != null && updateValues.Length > 0) { updateData = updateValues.Select(it => new KeyValuePair <TRoot, TRoot>(default(TRoot), it)).ToArray(); } } var deleteData = toDelete != null?serializer.Deserialize <TFormat, TRoot[]>(toDelete, locator) : null; if ((insertData == null || insertData.Length == 0) && (updateData == null || updateData.Length == 0) && (deleteData == null || deleteData.Length == 0)) { throw new ArgumentException( "Data not sent or deserialized unsuccessfully.", new FrameworkException(@"Example: " + serializer.Serialize( new Argument <TFormat> { RootName = typeof(TRoot).FullName, ToInsert = serializer.Serialize(new TRoot[] { new TRoot() }) }))); } try { return(repository.Persist(insertData, updateData, deleteData)); } catch (FrameworkException ex) { throw new ArgumentException(ex.Message, ex); } catch (Exception ex) { throw new ArgumentException( "Error persisting: {0}.".With(ex.Message), new FrameworkException( @"{0}{1}{2}".With( FormatData(serializer, "Insert", insertData), FormatData(serializer, "Update", updateData), FormatData(serializer, "Delete", deleteData)), ex)); } }
public async Task <HttpResponseMessage> PutAsync <T>(Uri requestUri, T payload) where T : class { var requestMessage = new HttpRequestMessage(HttpMethod.Put, requestUri); var content = new StringContent(serialization.Serialize(payload)); content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); requestMessage.Content = content; return(await MakeRequestAsync(requestMessage)); }
public TOutput Submit <TInput, TOutput>( ISerialization <TInput> input, ISerialization <TOutput> output, IServiceProvider locator, bool returnInstance, TInput data) { TEvent domainEvent; try { domainEvent = data != null?input.Deserialize <TInput, TEvent>(data, locator) : Activator.CreateInstance <TEvent>(); } catch (Exception ex) { throw new ArgumentException("Error deserializing domain event.", ex); } var domainStore = locator.Resolve <IEventStore>(); string uri; try { uri = domainStore.Submit(domainEvent); } catch (SecurityException) { throw; } catch (Exception ex) { throw new ArgumentException( ex.Message, data == null ? new FrameworkException("Error while submitting event: {0}. Data not sent.".With(ex.Message), ex) : new FrameworkException(@"Error while submitting event: {0}. Sent data: {1}".With(ex.Message, input.Serialize(domainEvent)), ex)); } try { if (returnInstance) { return(output.Serialize(domainEvent)); } else { return(output.Serialize(uri)); } } catch (Exception ex) { throw new ArgumentException( ex.Message, new FrameworkException(@"Error serializing result: " + ex.Message, ex)); } }
private static TOutput Serialize <TOutput>(ISerialization <TOutput> serializer, Stream stream) { if (typeof(TOutput) == typeof(object)) { return(serializer.Serialize(stream)); } using (var ms = new MemoryStream()) { stream.CopyTo(ms); stream.Dispose(); return(serializer.Serialize(ms.ToArray())); } }
public TOutput Update <TInput, TOutput>( ISerialization <TInput> input, ISerialization <TOutput> output, IServiceProvider locator, string uri, bool returnInstance, TInput data) { TRoot root; try { root = input.Deserialize <TInput, TRoot>(data, locator); } catch (Exception ex) { throw new ArgumentException( "Error deserializing: {0}".With(ex.Message), new FrameworkException(@"Sent data: {0}".With(data), ex)); } try { var repository = locator.Resolve <IPersistableRepository <TRoot> >(); var original = repository.Find(uri); if (original == null) { throw new ArgumentException("Can't find {0} with uri: {1}.".With(typeof(TRoot).FullName, uri)); } repository.Persist(null, new[] { new KeyValuePair <TRoot, TRoot>(original, root) }, null); return(returnInstance ? output.Serialize(root) : output.Serialize(root.URI)); } catch (Exception ex) { string additionalInfo; try { additionalInfo = @"Sent data: " + input.Serialize(root); } catch (Exception sex) { additionalInfo = "Error serializing input: " + sex.Message; } throw new ArgumentException( "Error saving: {0}.".With(ex.Message), new FrameworkException(additionalInfo, ex)); } }
public async void SaveAll() { var dataToSave = PlayerDetailsCache.Select(playerDetails => { var details = new PlayerDetailsDto { Handicap101 = playerDetails.Handicap101, Handicap201 = playerDetails.Handicap201, Handicap301 = playerDetails.Handicap301, Handicap401 = playerDetails.Handicap401, Handicap501 = playerDetails.Handicap501, HandicapCricket = playerDetails.HandicapCricket, Name = playerDetails.Name, NickName = playerDetails.NickName, Id = playerDetails.Id }; var definition = new ImageDefinitionDto { Name = playerDetails.PlayerImageDefinition.Name, SourceBytes = playerDetails.PlayerImageDefinition.SourceBytes }; details.PlayerImageDefinition = definition; details.SelectedFlight = playerDetails.SelectedFlight; return(details); }).ToList(); await _playerSerialiser.Serialize(dataToSave); }
public ICommandResult <TOutput> Execute <TInput, TOutput>( IServiceProvider locator, ISerialization <TInput> input, ISerialization <TOutput> output, IPrincipal principal, TInput data) { var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument); if (either.Error != null) { return(either.Error); } try { var command = PrepareCommand(principal, either.Argument.Name, either.Argument.SpecificationName); var exists = command.CheckExists(input, locator, either.Argument.Specification); return(CommandResult <TOutput> .Success(output.Serialize(exists), exists.ToString())); } catch (ArgumentException ex) { return(CommandResult <TOutput> .Fail( ex.Message, ex.GetDetailedExplanation() + @" Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output)))); } }
protected TOutput ExecuteCommand <TOutput>(ISerialization <TOutput> output, IServiceProvider locator, TCommand command) { var domainStore = locator.Resolve <IEventStore>(); try { domainStore.Submit(command); } catch (SecurityException) { throw; } catch (Exception ex) { throw new ArgumentException( ex.Message, new FrameworkException("Error while submitting query: {0}".With(ex.Message), ex)); } try { return(output.Serialize(OutMethod.Invoke(null, new object[] { command }))); } catch (Exception ex) { throw new ArgumentException( ex.Message, new FrameworkException(@"Error serializing result: " + ex.Message, ex)); } }
public ICommandResult <TOutput> Execute <TInput, TOutput>( IServiceProvider locator, ISerialization <TInput> input, ISerialization <TOutput> output, IPrincipal principal, TInput data) { var either = CommandResult <TOutput> .Check <Argument, TInput>(input, output, data, CreateExampleArgument); if (either.Error != null) { return(either.Error); } if (either.Argument.Uri == null) { return(CommandResult <TOutput> .Fail("Uri not provided.", @"Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output)))); } try { var arg = new GetDomainObject.Argument { Name = either.Argument.Name, Uri = new[] { either.Argument.Uri } }; var result = GetDomainObject.GetData(locator, arg, principal); return(CommandResult <TOutput> .Success(output.Serialize(result.Length == 1), result.Length == 1? "Found" : "Not found")); } catch (ArgumentException ex) { return(CommandResult <TOutput> .Fail( ex.Message, ex.GetDetailedExplanation() + @" Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output)))); } }
public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data) { var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument); if (either.Error != null) { return(either.Error); } try { var table = PopulateTable(input, output, Locator, DomainModel, either.Argument, Permissions); if (either.Argument.UseDataTable) { return(CommandResult <TOutput> .Return(HttpStatusCode.Created, output.Serialize(table), "Data analyzed")); } var result = ConvertTable.Convert(output, table); return(CommandResult <TOutput> .Return(HttpStatusCode.Created, result, "Data analyzed")); } catch (SecurityException ex) { return(CommandResult <TOutput> .Return(HttpStatusCode.Forbidden, default(TOutput), ex.Message)); } catch (ArgumentException ex) { return(CommandResult <TOutput> .Fail( ex.Message, ex.GetDetailedExplanation() + @" Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output)))); } }
public Stream ConvertStream <TCommand, TArgument>(TArgument argument) { var match = new UriTemplateMatch(); match.RelativePathSegments.Add(typeof(TCommand).FullName); ThreadContext.Request.UriTemplateMatch = match; if (argument == null) { return(Application.Get()); } switch (ThreadContext.Request.ContentType) { case "application/x-protobuf": return(Application.Post(Protobuf.Serialize(argument))); case "application/json": return(Application.Post(Json.Serialize(argument).BaseStream)); } using (var ms = ChunkedMemoryStream.Create()) { var sw = ms.GetWriter(); sw.Write(Xml.Serialize(argument)); sw.Flush(); ms.Position = 0; return(Application.Post(ms)); } }
public void Queue <TInput>( ISerialization <TInput> input, IServiceProvider locator, IDataContext context, TInput data) { TEvent domainEvent; try { domainEvent = data != null?input.Deserialize <TInput, TEvent>(data, locator) : Activator.CreateInstance <TEvent>(); } catch (Exception ex) { throw new ArgumentException("Error deserializing domain event.", ex); } try { context.Queue(domainEvent); } catch (SecurityException) { throw; } catch (Exception ex) { throw new ArgumentException( ex.Message, data == null ? new FrameworkException("Error while queuing event: {0}. Data not sent.".With(ex.Message), ex) : new FrameworkException(@"Error while queuing event: {0}. Sent data: {1}".With(ex.Message, input.Serialize(domainEvent)), ex)); } }
public void SendMessage(object obj) { if (obj == null) { return; } object sobj = _serialization.Serialize(obj); if (sobj is byte[]) { byte[] bytes = (byte[])sobj; if (bytes == null || bytes.Length == 0) { return; } IBytesMessage message = _service.session.CreateBytesMessage(); message.WriteBytes(bytes); _producer.Send(message); } else if (sobj is string) { string str = (string)sobj; ITextMessage txt = _service.session.CreateTextMessage(); _producer.Send(txt); } else { throw new Exception("obj is undefined type!"); } }
public void Create(TValue value) { EnsureFileExistence(); using (var writer = File.AppendText(fileName)) { writer.Write($"{serialization.Serialize(value)}\n"); } }
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer, Type rootType) { try { var array = Array.CreateInstance(rootType, 1); var element = TemporaryResources.CreateRandomObject(rootType); array.SetValue(element, 0); return(serializer.Serialize(new Argument <TFormat> { RootName = rootType.FullName, ToInsert = serializer.Serialize((dynamic)array) })); } catch { //fallback to simple example since sometimes calculated properties will throw exception during serialization return(CreateExampleArgument(serializer)); } }
public TOutput Queue <TInput, TOutput>( ISerialization <TInput> input, ISerialization <TOutput> output, IServiceProvider locator, string uri, TInput data) { TEvent domainEvent; try { domainEvent = data != null?input.Deserialize <TInput, TEvent>(data, locator) : Activator.CreateInstance <TEvent>(); } catch (Exception ex) { throw new ArgumentException("Error deserializing domain event.", ex); } var repository = locator.Resolve <IRepository <TAggregate> >(); var aggregate = repository.Find(uri); if (aggregate == null) { throw new ArgumentException("Can't find aggregate with Uri: {0}".With(uri)); } try { domainEvent.Apply(aggregate); } catch (SecurityException) { throw; } catch (Exception ex) { throw new ArgumentException(ex.Message, ex); } var eventStore = locator.Resolve <IDomainEventStore>(); try { eventStore.Queue(domainEvent); } catch (SecurityException) { throw; } catch (Exception ex) { throw new ArgumentException( ex.Message, data == null ? new FrameworkException("Error while Queuing event: {0}. Data not sent.".With(ex.Message), ex) : new FrameworkException(@"Error while Queuing event: {0}. Sent data: {1}".With(ex.Message, output.Serialize(domainEvent)), ex)); } return(output.Serialize(aggregate)); }
public ICommandResult <TOutput> Execute <TInput, TOutput>(ISerialization <TInput> input, ISerialization <TOutput> output, TInput data) { var either = CommandResult <TOutput> .Check <Argument <TInput>, TInput>(input, output, data, CreateExampleArgument); if (either.Error != null) { return(either.Error); } var argument = either.Argument; var rootType = DomainModel.Find(argument.RootName); if (rootType == null) { return(CommandResult <TOutput> .Fail("Couldn't find root type {0}.".With(argument.RootName), @"Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output)))); } if (!typeof(IAggregateRoot).IsAssignableFrom(rootType)) { return(CommandResult <TOutput> .Fail(@"Specified type ({0}) is not an aggregate root. Please check your arguments.".With(argument.RootName), null)); } if (!Permissions.CanAccess(rootType)) { return (CommandResult <TOutput> .Return( HttpStatusCode.Forbidden, default(TOutput), "You don't have permission to access: {0}.", argument.RootName)); } if (argument.ToInsert == null && argument.ToUpdate == null && argument.ToDelete == null) { return(CommandResult <TOutput> .Fail("Data to persist not specified.", @"Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output, rootType)))); } try { var commandType = typeof(PersistAggregateRootCommand <>).MakeGenericType(rootType); var command = Activator.CreateInstance(commandType) as IPersistAggregateRootCommand <IAggregateRoot>; var uris = command.Persist(input, Locator, argument.ToInsert, argument.ToUpdate, argument.ToDelete); return(CommandResult <TOutput> .Success(output.Serialize(uris), "Data persisted")); } catch (ArgumentException ex) { return(CommandResult <TOutput> .Fail( ex.Message, ex.GetDetailedExplanation() + @" Example argument: " + CommandResult <TOutput> .ConvertToString(CreateExampleArgument(output)))); } }
private Message Serialize(object o) { var type = o.GetType().Name; var data = _serialization.Serialize(o); var msg = new Message(data); msg.UserProperties["ClrType"] = msg; return(msg); }
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer, Type rootType) { try { return (serializer.Serialize( new Argument <TFormat> { Name = rootType.FullName, Data = serializer.Serialize((dynamic)TemporaryResources.CreateRandomObject(rootType)) })); } catch { //fallback to simple example since sometimes calculated properties will throw exception during serialization return(CreateExampleArgument(serializer)); } }
protected void EncodeRequest(IChannel channel, IByteBuffer buffer, Request req) { //Console.WriteLine("begin encode Request:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); ISerialization serialization = GetSerialization(channel); // Console.WriteLine("get serialization:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); // header. byte[] header = new byte[HeaderLength]; // set magic number. ByteUtil.Short2Bytes(Magic, header); // set request and serialization flag. header[2] = (byte)(FlagRequest | serialization.GetContentTypeId()); if (req.IsTwoWay) { header[2] |= FlagTwoway; } if (req.IsEvent) { header[2] |= FlagEvent; } // set request id. ByteUtil.Long2Bytes(req.Mid, header, 4); // encode request data. int savedWriteIndex = buffer.WriterIndex; buffer.SetWriterIndex(savedWriteIndex + HeaderLength); ChannelBufferStream bos = new ChannelBufferStream(buffer); IObjectOutput output = serialization.Serialize(bos); //Console.WriteLine("encode header:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); if (req.IsEvent) { EncodeEventData(channel, output, req.Mdata); } else { EncodeRequestData(channel, output, req.Mdata); } //Console.WriteLine("encode requestdata down:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); output.FlushBuffer(); bos.Flush(); bos.Close(); int len = bos.WritenBytes(); CheckPayload(channel, len); ByteUtil.Int2Bytes(len, header, 12); // write buffer.SetWriterIndex(savedWriteIndex); buffer.WriteBytes(header); // write header. buffer.SetWriterIndex(savedWriteIndex + HeaderLength + len); // Console.WriteLine("encode end:" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")); }
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer) { return (serializer.Serialize( new Argument <TFormat> { Name = "Module.Entity", SpecificationName = "Module.Entity+FindImportant" })); }
private static TFormat CreateExampleArgument <TFormat>(ISerialization <TFormat> serializer, Type rootType) { return (serializer.Serialize( new Argument { Name = rootType.FullName, Uri = "1001" })); }
public TOutput Create <TInput, TOutput>( ISerialization <TInput> input, ISerialization <TOutput> output, IServiceProvider locator, bool returnInstance, TInput data) { TRoot root; try { root = input.Deserialize <TInput, TRoot>(data, locator); } catch (Exception ex) { throw new ArgumentException( "Error deserializing: " + ex.Message, new FrameworkException(@"Sent data: {0}".With(data), ex)); } try { var repository = locator.Resolve <IPersistableRepository <TRoot> >(); repository.Insert(root); return(returnInstance ? output.Serialize(root) : output.Serialize(root.URI)); } catch (Exception ex) { string additionalInfo; try { additionalInfo = @"Sent data: " + input.Serialize(root); } catch (Exception sex) { additionalInfo = "Error serializing input: " + sex.Message; } throw new ArgumentException( "Error saving: " + ex.Message, new FrameworkException(additionalInfo, ex)); } }
public TOutput Transform(ISerialization <TInput> input, ISerialization <TOutput> output, TInput value) { var arg = input.Deserialize <TInput, string[]>(value); return(output.Serialize(new GetDomainObject.Argument { Name = Name, Uri = arg })); }
public TOutput Find <TOutput>( ISerialization <TOutput> output, IServiceLocator locator, IPermissionManager permissions, string uri) { var repository = locator.Resolve <IRepository <TDomainObject> >(); var data = repository.Find(new[] { uri }); var filtered = permissions.ApplyFilters(data).FirstOrDefault(); return(filtered != null?output.Serialize(filtered) : default(TOutput)); }
public async void SaveAll() { foreach (var statistic in _statisticsCache) { if (statistic.Value.PlayerId == Guid.Empty) { throw new Exception("INVALID PLAYER NAME"); } _statisticsSerialiser.FileName = statistic.Value.PlayerId + ".XML"; await _statisticsSerialiser.Serialize(statistic.Value); } }
public static void Send <T>(ISerialization serializer, StreamWriter stream, T item) { try { byte[] data = serializer.Serialize <T>(item); stream.Write(Encoding.UTF8.GetString(data).ToCharArray()); stream.Write('\0'); stream.Flush(); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }
/// <summary> /// Retruns bytes from the object /// </summary> /// <typeparam name="T">Type of the object</typeparam> /// <param name="input">Object to use for serialization</param> /// <param name="iSerialization">Serialization instance</param> /// <returns>Serialized byte array</returns> public static byte[] ToBytes <T>(this T _object, ISerialization _iSerialization) { if (IsSerializable <T>(_object) == false) { throw new InvalidOperationException("This object is not serializable"); } using (Stream stream = _iSerialization.Serialize <T>(_object)) { stream.Seek(0, SeekOrigin.Begin); byte[] retValue = new byte[stream.Length]; stream.Read(retValue, 0, retValue.Length); return(retValue); } }