public IDomainEvent Deserialize(ICommitedEvent commitedEvent)
{
var metadata = _textSerializer.Deserialize <Metadata>(commitedEvent.SerializedMetadata);
var eventClrType = metadata.GetValue(MetadataKeys.EventClrType);
return((IDomainEvent)_textSerializer.Deserialize(commitedEvent.SerializedData, eventClrType));
}
public ISnapshotRestore Deserialize(ICommitedSnapshot commitedSnapshot)
{
var metadata = _textSerializer.Deserialize <Metadata>(commitedSnapshot.SerializedMetadata);
var snapshotClrType = metadata.GetValue(MetadataKeys.SnapshotClrType, (value) => value.ToString());
var snapshot = (ISnapshot)_textSerializer.Deserialize(commitedSnapshot.SerializedData, snapshotClrType);
return(new SnapshotRestore(commitedSnapshot.AggregateId, commitedSnapshot.AggregateVersion, snapshot, metadata));
}
private IVersionedEvent Deserialize(EventData @event)
{
using (var reader = new StringReader(@event.Payload))
{
return((IVersionedEvent)serializer.Deserialize(reader));
}
}
/// <summary>
/// Deserializes the specified string into an object of type <typeparamref name="T"/>.
/// </summary>
/// <exception cref="System.InvalidCastException">The deserialized object is not of type <typeparamref name="T"/>.</exception>
public static T Deserialize <T>(this ITextSerializer serializer, string serialized)
{
using (var reader = new StringReader(serialized))
{
return((T)serializer.Deserialize(reader));
}
}
private static XProject ReadProject(ZipArchiveEntry projectEntry, IFileSystem fileIO, ITextSerializer serializer)
{
using (var entryStream = projectEntry.Open())
{
return(serializer.Deserialize <XProject>(fileIO.ReadUtf8Text(entryStream)));
}
}
private ICommandResult Parse(Task <Response> task)
{
if (task.Exception != null)
{
return(new CommandResult(HandleStatus.Failed, task.Exception.Message));
}
if (task.Result.Status != 200)
{
return(new CommandResult(HandleStatus.Failed, task.Result.Message));
}
var response = task.Result;
return(_serializer.Deserialize <CommandResult>(response.Message));
}
public async Task Handle(ApplyMakeChangeRequestChanges applyChangeRequestChanges)
{
if (String.IsNullOrWhiteSpace(applyChangeRequestChanges?.Entity))
{
throw new ArgumentNullException(nameof(applyChangeRequestChanges));
}
if (!applyChangeRequestChanges.Entity.ToLower().Equals(typeof(Make).Name.ToLower()))
{
throw new ArgumentException("Change request type invalid for applying make changes");
}
if (String.IsNullOrWhiteSpace(applyChangeRequestChanges.Payload))
{
throw new ArgumentNullException(nameof(applyChangeRequestChanges));
}
if (applyChangeRequestChanges.ChangeType != ChangeType.Modify)
{
return;
}
var make = _serializer.Deserialize <Make>(applyChangeRequestChanges.Payload);
if (make == null)
{
throw new ArgumentException("Make change request has some invalid payload");
}
await Handle(new ApplyMakeNameChange { Make = make });
}
private IVersionedEvent DeserializeObject(string payload)
{
using (var reader = new StringReader(payload))
{
return((IVersionedEvent)_serializer.Deserialize(reader));
}
}
private object Deserialize(string serialized)
{
using (var reader = new StringReader(serialized))
{
return(_serializer.Deserialize(reader));
}
}
private void ProcessingMessage(Message message)
{
if (LogManager.Default.IsDebugEnabled)
{
LogManager.Default.DebugFormat(
"Pull a message from kafka on topic('{0}'). offset:{1}, partition:{2}.",
_topic,
message.Offset,
message.PartitionId);
}
try
{
var serialized = _serializer.Deserialize <TDescriptor>(message.Payload);
var envelope = Convert(serialized, _serializer);
OnMessageReceived(this, envelope);
}
catch (OperationCanceledException)
{
}
catch (ThreadAbortException)
{
}
//catch (Exception) {
// throw;
//}
finally
{
_consumer.CommitOffset(_topic, message.PartitionId.Value, message.Offset, false);
}
}
public static T Deserialize <T>(Stream stream, ITextSerializer <T> textSerializer)
{
using (var textReader = StreamReaderHelper.NewLeaveOpen(stream))
{
var value = textSerializer.Deserialize(textReader);
return(value);
}
}
public override async Task <long> ChangeRequestItemExistAsync <TEntity>(Expression <Func <TEntity, bool> > whereCondition)
{
var existingChangeRequestItemStagings = await this._changeRequestItemStagingRepositoryService.GetAsync(
x => x.Entity.Equals(typeof(TEntity).Name, StringComparison.CurrentCultureIgnoreCase));
var predicate = whereCondition.Compile();
var matchingChangeRequestItemStagings = existingChangeRequestItemStagings.Where(changeRequest =>
new List <TEntity> {
_serializer.Deserialize <TEntity>(changeRequest.Payload)
}.Any(predicate)).ToList();
if (matchingChangeRequestItemStagings != null && matchingChangeRequestItemStagings.Any())
{
return(matchingChangeRequestItemStagings.First().ChangeRequestId);
}
return(0);
}
/// <summary>
/// Deserializes from stream.
/// </summary>
/// <returns>The from stream.</returns>
/// <param name="stream">Stream.</param>
/// <typeparam name="T">The type of object to deserialize.</typeparam>
public static T DeserializeFromStream <T>(this ITextSerializer serializer, Stream stream) where T : class
{
using (var streamReader = new StreamReader(stream))
{
var text = streamReader.ReadToEnd();
return(serializer.Deserialize <T>(text));
}
}
public static object DeserializeFromBytes(this ITextSerializer serializer, byte[] data, Type type,
Encoding encoding = null)
{
var encoder = encoding ?? Encoding.UTF8;
var str = encoder.GetString(data, 0, data.Length);
return(serializer.Deserialize(str, type));
}
public static bool CanSerializeEnumerable <T>(ITextSerializer serializer, IEnumerable <T> list, ITextSerializer deserializer)
{
var text = serializer.Serialize(list);
var obj = deserializer.Deserialize <IEnumerable <T> >(text);
return(obj.SequenceEqual(list));
}
public static SerializedEvent ApplyConsumerFilter(SerializedEvent e, string consumer, ITextSerializer serializer, Func<string, ITextSerializer, string, bool> filter)
{
if (filter(consumer, serializer, e.Payload))
return e;
var originalEvent = serializer.Deserialize<IEvent>(e.Payload);
var cloaked = new CloakedEvent(originalEvent.EventCollectionVersion, originalEvent.StreamType);
return new SerializedEvent(e.EventCollectionVersion, serializer.Serialize(cloaked));
}
protected virtual async Task ApprovedAddChangeRequestAction(ApprovedEvent <T> approvedEvent)
{
var deserializedEntity = Serializer.Deserialize <T>(approvedEvent.Payload);
deserializedEntity.Id = RepositoryService.GetMax(x => x.Id) + 1;
deserializedEntity.ChangeRequestId = approvedEvent.ChangeRequestId;
deserializedEntity.InsertDate = DateTime.UtcNow;
deserializedEntity.LastUpdateDate = DateTime.UtcNow;
//this.UpdateEntity(ref deserializedEntity, ChangeType.Add, approvedEvent.ChangeRequestId);
RepositoryService.Add(deserializedEntity);
if (await Repositories.SaveChangesAsync() > 0)
{
await DocumentIndexer.AddChangeRequestIndexerAsync(approvedEvent.ChangeRequestId);
await this.ClearChangeRequestId <T>(approvedEvent.ChangeRequestId);
}
}
public static T DeserializeFromString <T>(this ITextSerializer serializer, string input)
{
Condition.Requires(serializer, nameof(serializer)).IsNotNull();
var bytes = serializer.Encoding.GetBytes(input);
using (var stream = new MemoryStream(bytes))
{
return(serializer.Deserialize <T>(stream));
}
}
protected override Envelope <ICommand> Convert(CommandDescriptor descriptor, ITextSerializer serializer)
{
var type = Configuration.CommandTypes[descriptor.TypeName];
var command = (ICommand)serializer.Deserialize(descriptor.Metadata, type);
var envelope = new Envelope <ICommand>(command, descriptor.CommandId);
envelope.Items[StandardMetadata.TraceInfo] = new TraceInfo(descriptor.TraceId, descriptor.TraceAddress);
return(envelope);
}
protected override Envelope <IQuery> Convert(QueryDescriptor descriptor, ITextSerializer serializer)
{
var type = Configuration.QueryTypes[descriptor.TypeName];
var query = (IQuery)serializer.Deserialize(descriptor.Metadata, type);
var envelope = new Envelope <IQuery>(query, descriptor.TraceId);
envelope.Items[StandardMetadata.TraceInfo] = new TraceInfo(descriptor.TraceId, descriptor.TraceAddress);
return(envelope);
}
public T ValueAs <T>(ITextSerializer serializer = null)
{
if (serializer != null)
{
if (Value is string stringValue)
{
return(serializer.Deserialize <T>(stringValue));
}
else if (Value is JToken jTokenValue)
{
return(serializer.Deserialize <T>(jTokenValue.ToString()));
}
}
var jToken = Value as JToken;
return(jToken != null
? jToken.ToObject <T>()
: (T)Convert.ChangeType(Value, typeof(T)));
}
public static object DeserializeFromString(this ITextSerializer serializer, string input, Type type)
{
Condition.Requires(serializer, nameof(serializer)).IsNotNull();
Condition.Requires(type, nameof(type)).IsNotNull();
var bytes = serializer.Encoding.GetBytes(input);
using (var stream = new MemoryStream(bytes))
{
return(serializer.Deserialize(stream, type));
}
}
/// <summary>
/// 从字符串反序列化一个对象。
/// </summary>
public static T Deserialize <T>(this ITextSerializer serializer, string serialized)
where T : class
{
//using (var reader = new StringReader(serialized)) {
// if (resolveType)
// return (T)serializer.Deserialize(reader, typeof(T));
// else
// return (T)serializer.Deserialize(reader);
//}
return((T)serializer.Deserialize(serialized, typeof(T)));
}
/// <summary>
/// 初始化
/// </summary>
public void Initialize(IContainer container, IEnumerable <Type> types)
{
var messages = _messageStore.GetAll(_messageTypeName);
if (!messages.IsEmpty())
{
messages.Select(message => _serializer.Deserialize(message.Body))
.OfType <TMessage>().ForEach(AddToQueue);
}
this.Start();
}
public static SerializedEvent ApplyConsumerFilter(SerializedEvent e, string consumer, ITextSerializer serializer, Func <string, ITextSerializer, string, bool> filter)
{
if (filter(consumer, serializer, e.Payload))
{
return(e);
}
var originalEvent = serializer.Deserialize <IEvent>(e.Payload);
var cloaked = new CloakedEvent(originalEvent.EventCollectionVersion, originalEvent.StreamType);
return(new SerializedEvent(e.EventCollectionVersion, serializer.Serialize(cloaked)));
}
private IVersionedEvent Deserialize(Event @event)
{
using (var reader = new StringReader(@event.Payload))
{
var e = (IVersionedEvent)_serializer.Deserialize(reader);
if (e is IUpgradableEvent)
{
e = ((IUpgradableEvent)e).Upgrade();
}
return(e);
}
}
public override IAsyncResult BeginExecute(Request request, AsyncCallback callback, object state)
{
var responseTask = new TaskCompletionSource <Response>();
BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
{
if (_commandService.WaitingRequests > ConfigurationSettings.MaxRequests)
{
responseTask.SetResult(Response.ServerTooBusy);
return(CreateInnerAsyncResult(asyncCallback, asyncState));
}
Type type;
if (!BasicTypes.CommandTypes.TryGetValue(request.Header.GetIfKeyNotFound("Type"), out type))
{
responseTask.SetResult(Response.UnknownType);
return(CreateInnerAsyncResult(asyncCallback, asyncState));
}
ICommand command;
try
{
command = (ICommand)_serializer.Deserialize(request.Body, type);
}
catch (Exception)
{
responseTask.TrySetResult(Response.ParsingFailure);
return(CreateInnerAsyncResult(asyncCallback, asyncState));
}
var timeout = request.Header.GetIfKeyNotFound("Timeout", "0").ChangeIfError(0);
var returnMode = (CommandReturnMode)request.Header.GetIfKeyNotFound("Mode", "1").ChangeIfError(1);
var result = _commandService.Execute(command, returnMode, timeout);
var message = _serializer.Serialize(result);
responseTask.TrySetResult(new Response(200, message));
return(CreateInnerAsyncResult(asyncCallback, asyncState));
};
EndInvokeDelegate <Response> endDelegate =
delegate { return(responseTask.Task.Result); };
return(WrappedAsyncResult <Response> .Begin(
callback,
state,
beginDelegate,
endDelegate,
null,
Timeout.Infinite));
}
public void TestInitialize()
{
_serializer = Substitute.For <ITextSerializer <int>, IThrowsExpectedExceptions>();
_serializer
.Deserialize(Arg.Any <TextReader>())
.Returns(args => int.Parse(args.Arg <TextReader>().ReadToEnd()));
_serializer
.When(x => x.Serialize(Arg.Any <int>(), Arg.Any <TextWriter>()))
.Do(args => args.Arg <TextWriter>().Write(args.Arg <int>().ToString()));
_serializerFactory = Substitute.For <ITextSerializerFactory>();
_serializerFactory.Serializer <int>().Returns(_serializer);
}
public T As <T>(ITextSerializer serializer = null)
{
if (Token == null)
{
return(default(T));
}
if (serializer != null)
{
return(serializer.Deserialize <T>(Token.ToString()));
}
return(Token.ToObject <T>());
}
public object As(Type objectType, ITextSerializer serializer = null)
{
if (Token == null)
{
return(null);
}
if (serializer != null)
{
return(serializer.Deserialize(Token.ToString(), objectType));
}
return(Token.ToObject(objectType));
}
public static long GetDeserializationSpeed <T>(int numberOfIterations, ITextSerializer serializer, string text, out T deserialized, ITextSerializer deserializer)
{
deserialized = default(T);
var stopWatch = new Stopwatch();
stopWatch.Start();
for (var n = 0; n < numberOfIterations; n++)
{
deserialized = deserializer.Deserialize <T>(text);
}
stopWatch.Stop();
return(stopWatch.ElapsedMilliseconds);
}
public static void File(string input, string output = null, ITextSerializer serializer = null)
{
ConfigurationDictionary data;
TextReader fin;
fin = (input != "-") ? new StreamReader(input) : Console.In;
if (serializer == null)
{
if (input == "-" || !TryParseTextSerializer(Path.GetExtension(input).Substring(1), out serializer))
{
Console.Error.WriteLine("Serializer cannot be inferred");
return;
}
}
using (fin)
data = serializer.Deserialize(fin);
string generatorName;
IGenerator generator;
if (data.TryGetValueAs("Generator", out generatorName))
{
if (!TryParseGenerator(generatorName, out generator))
{
Console.Error.WriteLine($"Unknown generator \"{generatorName}\"");
return;
}
}
else
{
Console.Error.WriteLine("No generator specified");
return;
}
TextWriter fout;
if (output == null)
output = (input == "-") ? "-" : Path.ChangeExtension(input, generator.DefaultExtension(data));
fout = (output != "-") ? new StreamWriter(output) : Console.Out;
using (fout)
{
bool pd = input.IndexOfAny(new char[] { '/', '\\' }) != -1;
if (pd)
PushDirectory(Path.GetDirectoryName(input));
generator.Generate(data, fout);
if (pd)
PopDirectory();
}
}
public void MigrateEventSourcedAndGeneratePastEventLogs(
CloudTableClient messageLogClient, string messageLogName,
CloudTableClient originalEventStoreClient, string originalEventStoreName,
CloudTableClient newEventStoreClient, string newEventStoreName,
IMetadataProvider metadataProvider, ITextSerializer serializer)
{
retryPolicy.ExecuteAction(() => newEventStoreClient.CreateTableIfNotExist(newEventStoreName));
var currentEventStoreContext = newEventStoreClient.GetDataServiceContext();
string currentEventStorePartitionKey = null;
int currentEventStoreCount = 0;
var currentMessageLogContext = messageLogClient.GetDataServiceContext();
string currentMessageLogPartitionKey = null;
int currentMessageLogCount = 0;
foreach (var esEntry in this.GetAllEventSourcingEntries(originalEventStoreClient, originalEventStoreName))
{
// Copies the original values from the stored entry
var migratedEntry = Mapper.Map<EventTableServiceEntity>(esEntry);
// get the metadata, as it was not stored in the event store
var metadata = metadataProvider.GetMetadata(serializer.Deserialize<IVersionedEvent>(esEntry.Payload));
migratedEntry.AssemblyName = metadata[StandardMetadata.AssemblyName];
migratedEntry.FullName = metadata[StandardMetadata.FullName];
migratedEntry.Namespace = metadata[StandardMetadata.Namespace];
migratedEntry.TypeName = metadata[StandardMetadata.TypeName];
migratedEntry.CreationDate = esEntry.Timestamp.ToString("o");
if (currentEventStorePartitionKey == null)
{
currentEventStorePartitionKey = migratedEntry.PartitionKey;
++currentEventStoreCount;
}
else if (currentEventStorePartitionKey != migratedEntry.PartitionKey || ++currentEventStoreCount == 100)
{
retryPolicy.ExecuteAction(() => currentEventStoreContext.SaveChanges(SaveChangesOptions.Batch));
currentEventStoreContext = newEventStoreClient.GetDataServiceContext();
currentEventStorePartitionKey = migratedEntry.PartitionKey;
currentEventStoreCount = 0;
}
currentEventStoreContext.AddObject(newEventStoreName, migratedEntry);
const string RowKeyVersionLowerLimit = "0000000000";
const string RowKeyVersionUpperLimit = "9999999999";
if (migratedEntry.RowKey.CompareTo(RowKeyVersionLowerLimit) >= 0 &&
migratedEntry.RowKey.CompareTo(RowKeyVersionUpperLimit) <= 0)
{
var messageId = migratedEntry.PartitionKey + "_" + migratedEntry.RowKey; //This is the message ID used in the past (deterministic).
var logEntry = Mapper.Map<MessageLogEntity>(migratedEntry);
logEntry.PartitionKey = esEntry.Timestamp.ToString("yyyMM");
logEntry.RowKey = esEntry.Timestamp.Ticks.ToString("D20") + "_" + messageId;
logEntry.MessageId = messageId;
logEntry.CorrelationId = null;
logEntry.Kind = StandardMetadata.EventKind;
if (currentMessageLogPartitionKey == null)
{
currentMessageLogPartitionKey = logEntry.PartitionKey;
++currentMessageLogCount;
}
else if (currentMessageLogPartitionKey != logEntry.PartitionKey || ++currentMessageLogCount == 100)
{
retryPolicy.ExecuteAction(() => currentMessageLogContext.SaveChanges(SaveChangesOptions.Batch));
currentMessageLogContext = messageLogClient.GetDataServiceContext();
currentMessageLogPartitionKey = logEntry.PartitionKey;
currentMessageLogCount = 0;
}
currentMessageLogContext.AddObject(messageLogName, logEntry);
}
}
// save any remaining entries
retryPolicy.ExecuteAction(() => currentEventStoreContext.SaveChanges(SaveChangesOptions.Batch));
retryPolicy.ExecuteAction(() => currentMessageLogContext.SaveChanges(SaveChangesOptions.Batch));
}