public static byte[] SerializeToBytes(this IElasticsearchSerializer serializer, object data, SerializationFormatting formatting = SerializationFormatting.Indented) { using (var ms = new MemoryStream()) { serializer.Serialize(data, ms, formatting); return ms.ToArray(); } }
public async Task SerializeAsync <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented, CancellationToken cancellationToken = default) { string json = SerializeToString(data); using (var writer = new StreamWriter(stream)) { await writer.WriteAsync(json); } }
public Task SerializeAsync <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented, CancellationToken cancellationToken = default(CancellationToken) ) { //This makes no sense now but we need the async method on the interface in 6.x so we can start swapping this out //for an implementation that does make sense without having to wait for 7.x Serialize(data, stream, formatting); return(CompletedTask); }
public void Serialize <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented) { using (var writer = new StreamWriter(stream, ExpectedEncoding, BufferSize, true)) using (var jsonWriter = new JsonTextWriter(writer)) { var serializer = formatting == SerializationFormatting.Indented ? _serializer : _collapsedSerializer; serializer.Serialize(jsonWriter, data); } }
public override byte[] Serialize(object data, SerializationFormatting formatting = SerializationFormatting.Indented) { if (formatting == SerializationFormatting.None) { return(base.Serialize(data, formatting)); } JsConfig.EmitCamelCaseNames = true; return(Encoding.UTF8.GetBytes(data.ToJson())); }
public void Serialize <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented) { string json = SerializeToString(data); using (var writer = new StreamWriter(stream)) { writer.Write(json); } }
public byte[] Serialize(object data, SerializationFormatting formatting = SerializationFormatting.Indented) { var serialized = SimpleJson.SerializeObject(data); if (formatting == SerializationFormatting.None) { serialized = RemoveNewLinesAndTabs(serialized); } return(serialized.Utf8Bytes()); }
public void Serialize <T>(T data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.Indented) { var serialized = SimpleJson.SerializeObject(data, Strategy); if (formatting == SerializationFormatting.None) { serialized = RemoveNewLinesAndTabs(serialized); } using (var ms = new MemoryStream(serialized.Utf8Bytes())) ms.CopyTo(writableStream); }
public static string SerializeToString <T>(this IElasticsearchSerializer serializer, T data, SerializationFormatting formatting = SerializationFormatting.Indented ) { using (var ms = new MemoryStream()) { serializer.Serialize(data, ms, formatting); return(ms.Utf8String()); } }
public void Serialize <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented) { using (var writer = new StreamWriter(stream, ExpectedEncoding, BufferSize, leaveOpen: true)) using (var jsonWriter = new JsonTextWriter(writer)) { _defaultSerializer.Serialize(jsonWriter, data); writer.Flush(); jsonWriter.Flush(); } }
public Task SerializeAsync<T>( T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented, CancellationToken cancellationToken = default) { Serialize(data, stream, formatting); return Task.CompletedTask; }
public static byte[] SerializeToBytes <T>(this IElasticsearchSerializer serializer, T data, SerializationFormatting formatting = SerializationFormatting.Indented ) { using (var ms = new MemoryStream()) { serializer.Serialize(data, ms, formatting); return(ms.ToArray()); } }
public override void Serialize <T>(T data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.None) { if (data is IStreamSerializable streamSerializable) { streamSerializable.Serialize(writableStream, _settings, formatting); return; } base.Serialize(data, writableStream, formatting); }
public override Task SerializeAsync <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None, CancellationToken cancellationToken = default) { if (data is IStreamSerializable streamSerializable) { return(streamSerializable.SerializeAsync(stream, _settings, formatting)); } return(base.SerializeAsync(data, stream, formatting, cancellationToken)); }
private JsonSerializer CreateSerializer(SerializationFormatting formatting) { var s = CreateJsonSerializerSettings(); var converters = CreateJsonConverters() ?? Enumerable.Empty <JsonConverter>(); var contract = CreateContractResolver(); s.Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None; s.ContractResolver = contract; s.Converters = converters.Concat(this.Converters).ToList(); return(JsonSerializer.Create(s)); }
public async Task SerializeAsync <T>(T data, Stream writableStream, SerializationFormatting formatting, CancellationToken cancellationToken = default(CancellationToken) ) { var serialized = SimpleJson.SerializeObject(data, Strategy); if (formatting == SerializationFormatting.None) { serialized = RemoveNewLinesAndTabs(serialized); } using (var ms = new MemoryStream(serialized.Utf8Bytes())) await ms.CopyToAsync(writableStream).ConfigureAwait(false); }
public void Serialize <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None) { if (data is not PersistedEvent) { _builtIn.Serialize(data, stream, formatting); return; } var writer = new Utf8JsonWriter(stream); JsonSerializer.Serialize(writer, data, _options); }
public virtual void Serialize(object data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.Indented) { var serializer = _defaultSerializers[formatting]; using (var writer = new StreamWriter(writableStream, ExpectedEncoding, 8096, leaveOpen: true)) using (var jsonWriter = new JsonTextWriter(writer)) { serializer.Serialize(jsonWriter, data); writer.Flush(); jsonWriter.Flush(); } }
/// <inheritdoc cref="ITransportSerializer.Serialize{T}"/>> public void Serialize <T>(T data, Stream stream, SerializationFormatting formatting = None) { using var writer = new Utf8JsonWriter(stream); if (data == null) { JsonSerializer.Serialize(writer, null, typeof(object), GetFormatting(formatting)); } //TODO validate if we can avoid boxing by checking if data is typeof(object) else { JsonSerializer.Serialize(writer, data, data.GetType(), GetFormatting(formatting)); } }
public override byte[] Serialize(object data, SerializationFormatting formatting = SerializationFormatting.Indented) { var modifier = GetModifier(data); if (modifier != null) modifier.ModifySearch(data); try { return base.Serialize(data, formatting); } catch (JsonWriterException exception) { Logger.WriteToLog($"PreSerializationProccessor failed. data type: {data.GetType().Name}",Level.Error,exception); return null; } }
/// <inheritdoc cref="ITransportSerializer.SerializeAsync{T}"/>> public async Task SerializeAsync <T>(T data, Stream stream, SerializationFormatting formatting = None, CancellationToken cancellationToken = default ) { if (data == null) { await JsonSerializer.SerializeAsync(stream, null, typeof(object), GetFormatting(formatting), cancellationToken).ConfigureAwait(false); } else { await JsonSerializer.SerializeAsync(stream, data, data.GetType(), GetFormatting(formatting), cancellationToken).ConfigureAwait(false); } }
public void Serialize<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented) { var writer = new StreamWriter(stream); using (var jWriter = new JsonTextWriter(writer)) { var serializer = new JsonSerializer { Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None }; serializer.Serialize(jWriter, data); } }
public static byte[] SerializeToBytes <T>( this IElasticsearchSerializer serializer, T data, IMemoryStreamFactory memoryStreamFactory = null, SerializationFormatting formatting = SerializationFormatting.Indented ) { memoryStreamFactory = memoryStreamFactory ?? RecyclableMemoryStreamFactory.Default; using (var ms = memoryStreamFactory.Create()) { serializer.Serialize(data, ms, formatting); return(ms.ToArray()); } }
/// <summary> /// Extension method that serializes an instance of <typeparamref name="T"/> to a string. /// </summary> /// <param name="memoryStreamFactory"> /// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/> /// that yields memory streams backed by pooled byte arrays. /// </param> public static string SerializeToString <T>( this IElasticsearchSerializer serializer, T data, IMemoryStreamFactory memoryStreamFactory, SerializationFormatting formatting = SerializationFormatting.None ) { memoryStreamFactory ??= RecyclableMemoryStreamFactory.Default; using (var ms = memoryStreamFactory.Create()) { serializer.Serialize(data, ms, formatting); return(ms.Utf8String()); } }
/// <summary> /// Extension method that serializes an instance of <typeparamref name="T"/> to a byte array. /// </summary> /// <param name="memoryStreamFactory"> /// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/> /// that yields memory streams backed by pooled byte arrays. /// </param> public static byte[] SerializeToBytes <T>( this IElasticsearchSerializer serializer, T data, IMemoryStreamFactory memoryStreamFactory, SerializationFormatting formatting = SerializationFormatting.None ) { memoryStreamFactory ??= ConnectionConfiguration.DefaultMemoryStreamFactory; using (var ms = memoryStreamFactory.Create()) { serializer.Serialize(data, ms, formatting); return(ms.ToArray()); } }
/// <summary> /// Extension method that serializes an instance of <typeparamref name="T"/> to a string. /// </summary> /// <param name="memoryStreamFactory"> /// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/> /// that yields memory streams backed by pooled byte arrays. /// </param> public static string SerializeToString <T>( this ITransportSerializer serializer, T data, IMemoryStreamFactory memoryStreamFactory, SerializationFormatting formatting = SerializationFormatting.None ) { memoryStreamFactory ??= TransportConfiguration.DefaultMemoryStreamFactory; using (var ms = memoryStreamFactory.Create()) { serializer.Serialize(data, ms, formatting); return(ms.Utf8String()); } }
/// <summary> /// Extension method that serializes an instance of <typeparamref name="T"/> to a byte array. /// </summary> /// <param name="memoryStreamFactory"> /// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/> /// that yields memory streams backed by pooled byte arrays. /// </param> public static byte[] SerializeToBytes <T>( this IOpenSearchSerializer serializer, T data, IMemoryStreamFactory memoryStreamFactory, SerializationFormatting formatting = SerializationFormatting.None ) { memoryStreamFactory ??= RecyclableMemoryStreamFactory.Default; using (var ms = memoryStreamFactory.Create()) { serializer.Serialize(data, ms, formatting); return(ms.ToArray()); } }
public void Serialize <T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.Indented) { //using (var ms = new MemoryStream()) //{ // Serializer.Serialize(ms, data); // ms.Position = 0; // using (GZipStream compressionStream = new GZipStream(stream, CompressionMode.Compress)) // { // ms.CopyTo(compressionStream); // } //} Serializer.Serialize(stream, data); }
private JsonSerializer CreateSerializer(SerializationFormatting formatting) { var s = CreateJsonSerializerSettings() ?? new JsonSerializerSettings(); var converters = CreateJsonConverters() ?? Enumerable.Empty <JsonConverter>(); var contract = CreateContractResolver(); s.Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None; s.ContractResolver = contract; foreach (var converter in converters.Concat(Converters)) { s.Converters.Add(converter); } return(JsonSerializer.Create(s)); }
/// <summary> /// Serialize data /// </summary> /// <param name="data"></param> /// <param name="writableStream"></param> /// <param name="formatting"></param> public override void Serialize(object data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.Indented) { // ReSharper disable once MergeCastWithTypeCheck if (data is IndexDescriptor <IContent> descriptedData) { // write all but ending } CopyDataToStream(data, writableStream, formatting); var content = ((IIndexRequest <IContent>)descriptedData).Document; if (content != null && _vulcanModifiers != null) { // try to inspect to see if a pipeline was enabled var requestAccessor = (IRequest <IndexRequestParameters>)data; var pipelineId = requestAccessor.RequestParameters?.GetQueryStringValue <string>("pipeline"); // returns null if key not found var args = new VulcanIndexingModifierArgs(content, pipelineId); foreach (var indexingModifier in _vulcanModifiers) { try { indexingModifier.ProcessContent(args); } catch (Exception e) { throw new Exception($"{indexingModifier.GetType().FullName} failed to process content ID {content.ContentLink.ID} with name {content.Name}!", e); } } // add separator for additional items if any if (args.AdditionalItems.Any()) { WriteToStream(" , ", writableStream); } // copy all but starting { CopyDataToStream(args.AdditionalItems, writableStream, formatting, false); } else { WriteToStream("}", writableStream); // add back closing } } else { base.Serialize(data, writableStream, formatting); } }
public virtual void Serialize <T>(T data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.Indented) { var serializer = formatting == SerializationFormatting.Indented ? _indentedSerializer : _defaultSerializer; //this leaveOpen is most likely here because in PostData when we serialize IEnumerable<object> as multi json //we call this multiple times, it would be better to have a dedicated Serialize(IEnumerable<object>) on the //IElasticsearchSerializer interface more explicitly using (var writer = new StreamWriter(writableStream, ExpectedEncoding, BufferSize, leaveOpen: true)) using (var jsonWriter = new JsonTextWriter(writer)) { serializer.Serialize(jsonWriter, data); writer.Flush(); jsonWriter.Flush(); } }
private JsonSerializerSettings CreateSettings(SerializationFormatting formatting) { var settings = new JsonSerializerSettings() { Formatting = formatting == SerializationFormatting.Indented ? Formatting.Indented : Formatting.None, ContractResolver = this.ContractResolver, DefaultValueHandling = DefaultValueHandling.Include, NullValueHandling = NullValueHandling.Ignore }; if (!(settings.ContractResolver is ElasticContractResolver contract)) { throw new Exception($"NEST needs an instance of {nameof(ElasticContractResolver)} registered on Json.NET's JsonSerializerSettings"); } return(settings); }
public static string SerializeToString(this IElasticsearchSerializer serializer, object data, SerializationFormatting formatting = SerializationFormatting.Indented) => serializer.SerializeToBytes(data, formatting).Utf8String();