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();
