public async Task PublishAsync <T>(T myEvent)
{
var serializedEvent = JsonConvert.SerializeObject(myEvent);
var eventBytes = Encoding.UTF8.GetBytes(serializedEvent);
var eventData = new EventData(eventBytes);
await eventHubClient.SendAsync(eventData);
}
private async Task Publish(EventHubClient client, QuickBlockTransferSegment segment)
{
try
{
await client.SendAsync(new EventData(segment.Content)
{
PartitionKey = segment.GetKey(),
Properties =
{
{nameof(segment.Header), segment.Header},
{nameof(segment.ReceivedAt), segment.ReceivedAt},
{nameof(segment.Filename), segment.Filename},
{nameof(segment.TimeStamp), segment.TimeStamp},
{nameof(segment.Checksum), segment.Checksum},
{nameof(segment.BlockNumber), segment.BlockNumber},
{nameof(segment.TotalBlocks), segment.TotalBlocks},
{nameof(segment.Version), segment.Version},
{nameof(segment.Source), segment.Source}
}
});
}
catch (Exception ex)
{
_log.Error(ex.ToString());
}
}
/// <summary>
/// Creates the event sender action block.
/// </summary>
/// <param name="hubClient">The hub client.</param>
/// <param name="options">The options.</param>
/// <returns>ActionBlock<System.Byte[]>.</returns>
public static ActionBlock<byte[]> Create(EventHubClient hubClient, ExecutionDataflowBlockOptions options)
{
return new ActionBlock<byte[]>(data =>
{
//var index = Array.IndexOf(data, (byte)'>');
//if (index < 0) return Task.FromResult(0);
//var key = Encoding.UTF8.GetString(data, 0, index);
var eventData = new EventData(data);
return hubClient.SendAsync(eventData);
}, options);
}
///// <summary>
///// This method can be used to send an event data to an event hub.
///// </summary>
///// <param name="eventHubClient">A EventHubClient object used to send messages.</param>
///// <param name="eventDataList">The list of messages to send.</param>
///// <param name="messageNumberList">The list of message numbers.</param>
///// <param name="taskId">The sender task id.</param>
///// <param name="logging">Indicates whether logging of message content and properties is enabled.</param>
///// <param name="verbose">Indicates whether verbose logging is enabled.</param>
///// <returns>Elapsed milliseconds.</returns>
//public async Task<long> SendEventDataBatch(EventHubClient eventHubClient,
// List<EventData> eventDataList,
// List<long> messageNumberList,
// int taskId,
// bool logging,
// bool verbose)
//{
// long elapsedMilliseconds = 0;
// if (eventHubClient == null)
// {
// throw new ArgumentNullException(EventHubClientCannotBeNull);
// }
// if (eventDataList == null || eventDataList.Count == 0)
// {
// return elapsedMilliseconds;
// }
// List<Stream> eventDataPayloadList = null;
// var stopwatch = new Stopwatch();
// var builder = new StringBuilder();
// try
// {
// stopwatch.Start();
// if (logging && verbose)
// {
// eventDataPayloadList = eventDataList.Select(e => e.Clone().GetBodyStream()).ToList();
// }
// //await eventHubClient.SendBatchAsync(eventDataList);
// }
// finally
// {
// stopwatch.Stop();
// }
// elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
// if (logging)
// {
// for (var i = 0; i < eventDataList.Count; i++)
// {
// try
// {
// builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
// EventDataSuccessfullySent,
// taskId,
// messageNumberList[i],
// string.IsNullOrWhiteSpace(eventDataList[i].PartitionKey)
// ? NullValue
// : eventDataList[i].PartitionKey));
// if (verbose)
// {
// builder.AppendLine(SentMessagePayloadHeader);
// builder.AppendLine(string.Format(MessageTextFormat, GetMessageText(eventDataPayloadList[i])));
// builder.AppendLine(SentMessagePropertiesHeader);
// foreach (var p in eventDataList[i].Properties)
// {
// builder.AppendLine(string.Format(MessagePropertyFormat,
// p.Key,
// p.Value));
// }
// }
// }
// finally
// {
// eventDataList[i].Dispose();
// }
// }
// var traceMessage = builder.ToString();
// WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
// }
// return elapsedMilliseconds;
//}
/// <summary>
/// This method can be used to send an event data to an event hub.
/// </summary>
/// <param name="eventHubClient">A MessageSender object used to send event datas.</param>
/// <param name="eventData">The event data to send.</param>
/// <param name="messageNumber">The message number.</param>
/// <param name="taskId">The sender task id.</param>
/// <param name="logging">Indicates whether logging of event data content and properties is enabled.</param>
/// <param name="verbose">Indicates whether verbose logging is enabled.</param>
/// <returns>Elapsed milliseconds.</returns>
public async Task<long> SendEventData(EventHubClient eventHubClient,
EventData eventData,
long messageNumber,
int taskId,
bool logging,
bool verbose)
{
long elapsedMilliseconds;
if (eventHubClient == null)
{
throw new ArgumentNullException(MessageSenderCannotBeNull);
}
if (eventData == null)
{
throw new ArgumentNullException(BrokeredMessageCannotBeNull);
}
var stopwatch = new Stopwatch();
Stream bodyStream = null;
try
{
var builder = new StringBuilder();
try
{
if (logging && verbose)
{
bodyStream = eventData.Clone().GetBodyStream();
}
stopwatch.Start();
await eventHubClient.SendAsync(eventData);
}
finally
{
stopwatch.Stop();
}
elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (logging)
{
builder.AppendLine(string.Format(CultureInfo.CurrentCulture,
EventDataSuccessfullySent,
taskId,
messageNumber,
string.IsNullOrWhiteSpace(eventData.PartitionKey) ? NullValue : eventData.PartitionKey));
if (verbose)
{
builder.AppendLine(SentMessagePayloadHeader);
builder.AppendLine(string.Format(MessageTextFormat, GetMessageText(bodyStream)));
if (eventData.Properties.Any())
{
builder.AppendLine(SentMessagePropertiesHeader);
foreach (var p in eventData.Properties)
{
builder.AppendLine(string.Format(MessagePropertyFormat,
p.Key,
p.Value));
}
}
}
var traceMessage = builder.ToString();
WriteToLog(traceMessage.Substring(0, traceMessage.Length - 1));
}
}
finally
{
eventData.Dispose();
}
return elapsedMilliseconds;
}
private static async Task SendRowsToEventHub(EventHubClient eventHubClient, IEnumerable<object> rows)
{
var memoryStream = new MemoryStream();
using (var sw = new StreamWriter(memoryStream, new UTF8Encoding(false), 1024, leaveOpen: true))
{
string serialized = JsonConvert.SerializeObject(rows);
sw.Write(serialized);
sw.Flush();
}
Debug.Assert(memoryStream.Position > 0, "memoryStream.Position > 0");
memoryStream.Position = 0;
EventData eventData = new EventData(memoryStream);
await eventHubClient.SendAsync(eventData);
}
