Microsoft.Azure.EventHubs
Provides an adapter from TokenProvider to ICbsTokenProvider for AMQP CBS usage.
The data structure encapsulating the Event being sent-to and received-from EventHubs.
Each EventHubs partition can be visualized as a Stream of EventData.
Construct EventData to send to EventHub.
Typical pattern to create a Sending EventData is:
i. Serialize the sending ApplicationEvent to be sent to EventHubs into bytes.
ii. If complex serialization logic is involved (for example: multiple types of data) - add a Hint using the for the Consumer.
Sample Code:
EventData eventData = new EventData(telemetryEventBytes);
eventData.Properties["eventType"] = "com.microsoft.azure.monitoring.EtlEvent";
await partitionSender.SendAsync(eventData);
The actual payload of data in bytes to be sent to the EventHub.
Construct EventData to send to EventHub.
Typical pattern to create a Sending EventData is:
i. Serialize the sending ApplicationEvent to be sent to EventHub into bytes.
ii. If complex serialization logic is involved (for example: multiple types of data) - add a Hint using the for the Consumer.
Sample Code:
EventData eventData = new EventData(new ArraySegment<byte>(eventBytes, offset, count));
eventData.Properties["eventType"] = "com.microsoft.azure.monitoring.EtlEvent";
await partitionSender.SendAsync(eventData);
The payload bytes, offset and length to be sent to the EventHub.
Get the actual Payload/Data wrapped by EventData.
This is intended to be used after receiving EventData using .
Application property bag
SystemProperties that are populated by EventHubService.
As these are populated by Service, they are only present on a Received EventData.
Disposes resources attached to an Event Data
A collection used to store properties which are set by the Event Hubs service.
Gets the logical sequence number of the event within the partition stream of the Event Hub.
Gets or sets the date and time of the sent time in UTC.
The enqueue time in UTC. This value represents the actual time of enqueuing the message.
Gets the offset of the data relative to the Event Hub partition stream. The offset is a marker or identifier for an event within the Event Hubs stream. The identifier is unique within a partition of the Event Hubs stream.
Gets the partition key of the corresponding partition that stored the
A helper class for creating a batch of EventData objects to be used for SendBatch or SendBatchAsync call.
Creates a new .
The maximum size allowed for the batch
Gets the current event count in the batch.
Tries to add an event data to the batch if permitted by the batch's size limit.
The to add.
A boolean value indicating if the event data has been added to the batch or not.
Thrown when the EventData is null.
Thrown when the batch is already disposed.
This method checks the sizes of the batch, the EventData object and the specified limit to determine
if the EventData object can be added.
Converts the batch to an IEnumerable of EventData objects that can be accepted by the
SendBatchAsync method.
Returns an IEnumerable of EventData objects.
Disposes resources attached to an EventDataBatch.
Anchor class - all EventHub client operations start here.
See
Gets the name of the EventHub.
Creates a new instance of the Event Hubs client using the specified connection string. You can populate the EntityPath property with the name of the Event Hub.
Closes and releases resources associated with .
Send to EventHub. The sent EventData will land on any arbitrarily chosen EventHubs partition.
There are 3 ways to send to EventHubs, each exposed as a method (along with its sendBatch overload):
i. or
ii. or
iii. or
Use this method to send if:
a) the operation should be highly available and
b) the data needs to be evenly distributed among all partitions; exception being, when a subset of partitions are unavailable
sends the to a Service Gateway, which in-turn will forward the EventData to one of the EventHub's partitions.
Here's the message forwarding algorithm:
i. Forward the EventDatas to EventHub partitions, by equally distributing the data among all partitions (ex: Round-robin the EventDatas to all EventHub partitions)
ii. If one of the EventHub partitions is unavailable for a moment, the Service Gateway will automatically detect it and forward the message to another available partition - making the send operation highly-available.
the to be sent.
A Task that completes when the send operations is done.
Send a batch of to EventHub. The sent EventData will land on any arbitrarily chosen EventHub partition.
This is the most recommended way to send to EventHub.
There are 3 ways to send to EventHubs, to understand this particular type of send refer to the overload , which is used to send single .
Use this overload if you need to send a batch of .
Sending a batch of 's is useful in the following cases:
i. Efficient send - sending a batch of maximizes the overall throughput by optimally using the number of sessions created to EventHub's service.
ii. Send multiple 's in a Transaction. To acheieve ACID properties, the Gateway Service will forward all 's in the batch to a single EventHub partition.
Sample code:
var client = EventHubClient.Create("__connectionString__");
while (true)
{
var events = new List<EventData>();
for (int count = 1; count < 11; count++)
{
var payload = new PayloadEvent(count);
byte[] payloadBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload));
var sendEvent = new EventData(payloadBytes);
var applicationProperties = new Dictionary<string, string>();
applicationProperties["from"] = "csharpClient";
sendEvent.Properties = applicationProperties;
events.Add(sendEvent);
}
await client.SendAsync(events);
Console.WriteLine("Sent Batch... Size: {0}", events.Count);
}
A batch of events to send to EventHub
A Task that completes when the send operations is done.
Sends an ' with a partitionKey to EventHub. All 's with a partitionKey are guaranteed to land on the same partition.
This send pattern emphasize data correlation over general availability and latency.
There are 3 ways to send to EventHubs, each exposed as a method (along with its batched overload):
i. or
ii. or
iii. or
Use this type of send if:
a) There is a need for correlation of events based on Sender instance; The sender can generate a UniqueId and set it as partitionKey - which on the received Message can be used for correlation
b) The client wants to take control of distribution of data across partitions.
Multiple PartitionKeys could be mapped to one Partition. EventHubs service uses a proprietary Hash algorithm to map the PartitionKey to a PartitionId.
Using this type of send (Sending using a specific partitionKey) could sometimes result in partitions which are not evenly distributed.
the to be sent.
the partitionKey will be hashed to determine the partitionId to send the EventData to. On the Received message this can be accessed at .
A Task that completes when the send operation is done.
Send a 'batch of with the same partitionKey' to EventHub. All 's with a partitionKey are guaranteed to land on the same partition.
Multiple PartitionKey's will be mapped to one Partition.
There are 3 ways to send to EventHubs, to understand this particular type of send refer to the overload ,
which is the same type of send and is used to send single .
Sending a batch of 's is useful in the following cases:
i. Efficient send - sending a batch of maximizes the overall throughput by optimally using the number of sessions created to EventHubs service.
ii. Sending multiple events in One Transaction. This is the reason why all events sent in a batch needs to have same partitionKey (so that they are sent to one partition only).
the batch of events to send to EventHub
the partitionKey will be hashed to determine the partitionId to send the EventData to. On the Received message this can be accessed at .
A Task that completes when the send operation is done.
Create a which can publish 's directly to a specific EventHub partition (sender type iii. in the below list).
There are 3 patterns/ways to send to EventHubs:
i. or
ii. or
iii. or
partitionId of EventHub to send the 's to.
The created PartitionSender
Create a receiver for a specific EventHub partition from the specific consumer group.
NOTE: There can be a maximum number of receivers that can run in parallel per ConsumerGroup per Partition.
The limit is enforced by the Event Hub service - current limit is 5 receivers in parallel. Having multiple receivers
reading from offsets that are far apart on the same consumer group / partition combo will have significant performance Impact.
the consumer group name that this receiver should be grouped under.
the partition Id that the receiver belongs to. All data received will be from this partition only.
the offset to start receiving the events from. To receive from start of the stream use
The created PartitionReceiver
Create the EventHub receiver with given partition id and start receiving from the specified starting offset.
The receiver is created for a specific EventHub Partition from the specific consumer group.
the consumer group name that this receiver should be grouped under.
the partition Id that the receiver belongs to. All data received will be from this partition only.
the offset to start receiving the events from. To receive from start of the stream use:
if set to true, the startingOffset is treated as an inclusive offset - meaning the first event returned is the
one that has the starting offset. Normally first event returned is the event after the starting offset.
The created PartitionReceiver
Create the EventHub receiver with given partition id and start receiving from the specified starting offset.
The receiver is created for a specific EventHub Partition from the specific consumer group.
the consumer group name that this receiver should be grouped under.
the partition Id that the receiver belongs to. All data received will be from this partition only.
the DateTime instant that receive operations will start receive events from. Events received will have later than this Instant.
The created PartitionReceiver
Create a Epoch based EventHub receiver with given partition id and start receiving from the beginning of the partition stream.
The receiver is created for a specific EventHub Partition from the specific consumer group.
It is important to pay attention to the following when creating epoch based receiver:
- Ownership enforcement: Once you created an epoch based receiver, you cannot create a non-epoch receiver to the same consumerGroup-Partition combo until all receivers to the combo are closed.
- Ownership stealing: If a receiver with higher epoch value is created for a consumerGroup-Partition combo, any older epoch receiver to that combo will be force closed.
- Any receiver closed due to lost of ownership to a consumerGroup-Partition combo will get ReceiverDisconnectedException for all operations from that receiver.
the consumer group name that this receiver should be grouped under.
the partition Id that the receiver belongs to. All data received will be from this partition only.
the offset to start receiving the events from. To receive from start of the stream use
an unique identifier (epoch value) that the service uses, to enforce partition/lease ownership.
The created PartitionReceiver
Create a Epoch based EventHub receiver with given partition id and start receiving from the beginning of the partition stream.
The receiver is created for a specific EventHub Partition from the specific consumer group.
It is important to pay attention to the following when creating epoch based receiver:
- Ownership enforcement: Once you created an epoch based receiver, you cannot create a non-epoch receiver to the same consumerGroup-Partition combo until all receivers to the combo are closed.
- Ownership stealing: If a receiver with higher epoch value is created for a consumerGroup-Partition combo, any older epoch receiver to that combo will be force closed.
- Any receiver closed due to lost of ownership to a consumerGroup-Partition combo will get ReceiverDisconnectedException for all operations from that receiver.
the consumer group name that this receiver should be grouped under.
the partition Id that the receiver belongs to. All data received will be from this partition only.
the offset to start receiving the events from. To receive from start of the stream use
if set to true, the startingOffset is treated as an inclusive offset - meaning the first event returned is the one that has the starting offset. Normally first event returned is the event after the starting offset.
an unique identifier (epoch value) that the service uses, to enforce partition/lease ownership.
The created PartitionReceiver
Create a Epoch based EventHub receiver with given partition id and start receiving from the beginning of the partition stream.
The receiver is created for a specific EventHub Partition from the specific consumer group.
It is important to pay attention to the following when creating epoch based receiver:
- Ownership enforcement: Once you created an epoch based receiver, you cannot create a non-epoch receiver to the same consumerGroup-Partition combo until all receivers to the combo are closed.
- Ownership stealing: If a receiver with higher epoch value is created for a consumerGroup-Partition combo, any older epoch receiver to that combo will be force closed.
- Any receiver closed due to lost of ownership to a consumerGroup-Partition combo will get ReceiverDisconnectedException for all operations from that receiver.
the consumer group name that this receiver should be grouped under.
the partition Id that the receiver belongs to. All data received will be from this partition only.
the date time instant that receive operations will start receive events from. Events received will have later than this instant.
a unique identifier (epoch value) that the service uses, to enforce partition/lease ownership.
The created PartitionReceiver
Retrieves EventHub runtime information
Retrieves runtime information for the specified partition of the Event Hub.
The partition ID.
Returns .
Creates a batch where event data objects can be added for later SendAsync call.
Returns .
Contains information regarding an event hub partition.
Gets the path of the event hub.
The path of the event hub.
Gets the partition ID for a logical partition of an Event Hub.
The partition identifier.
Gets the begin sequence number.
The begin sequence number.
Gets the end sequence number.
The end sequence number.
Gets the offset of the last enqueued event.
The offset of the last enqueued event.
Gets the enqueued UTC time of the last event.
The enqueued time of the last event.
Contains information regarding Event Hubs.
Gets or sets the path to the Event Hub.
Gets or sets the time at which the Event Hub was created.
Gets or sets the number of partitions in an Event Hub.
Gets or sets the partition IDs for an Event Hub.
EventSource for Microsoft-Azure-EventHubs traces.
When defining Start/Stop tasks, the StopEvent.Id must be exactly StartEvent.Id + 1.
Do not explicity include the Guid here, since EventSource has a mechanism to automatically
map to an EventSource Guid based on the Name (Microsoft-Azure-EventHubs).
A handler interface for the receive operation. Use any implementation of this interface to specify
user action when using .
Gets the maximum batch size.
Users should implement this method to specify the action to be performed on the received events.
The list of fetched events from the corresponding PartitionReceiver.
Implement in order to handle exceptions that are thrown during receipt of events.
The to be processed
An asynchronour operation
This is a logical representation of receiving from a EventHub partition.
A PartitionReceiver is tied to a ConsumerGroup + Partition combination. If you are creating an epoch based
PartitionReceiver (i.e. PartitionReceiver.Epoch != 0) you cannot have more than one active receiver per
ConsumerGroup + Partition combo. You can have multiple receivers per ConsumerGroup + Partition combination with
non-epoch receivers.
This is a constant defined to represent the start of a partition stream in EventHub.
The constant that denotes the end of a stream. This can be used as an offset argument in receiver creation to
start receiving from the latest event, instead of a specific point in time/offset value.
The default consumer group name: $Default.
The EventHubClient this PartitionReceiver was created from.
The Consumer Group Name
Get the EventHub partition identifier.
The identifier representing the partition from which this receiver is fetching data
Get Prefetch Count configured on the Receiver.
The upper limit of events this receiver will actively receive regardless of whether a receive operation is pending.
Get the epoch value that this receiver is currently using for partition ownership.
A value of null means this receiver is not an epoch-based receiver.
the epoch value that this receiver is currently using for partition ownership.
Receive a batch of 's from an EventHub partition
Sample code:
EventHubClient client = EventHubClient.Create("__connectionString__");
PartitionReceiver receiver = client.CreateReceiver("ConsumerGroup1", "1");
IEnumerable<EventData> receivedEvents = await receiver.ReceiveAsync(BatchSize);
while (true)
{
int batchSize = 0;
if (receivedEvents != null)
{
foreach (EventData receivedEvent in receivedEvents)
{
Console.WriteLine("Message Payload: {0}", Encoding.UTF8.GetString(receivedEvent.Body));
Console.WriteLine("Offset: {0}, SeqNo: {1}, EnqueueTime: {2}",
receivedEvent.SystemProperties.Offset,
receivedEvent.SystemProperties.SequenceNumber,
receivedEvent.SystemProperties.EnqueuedTime);
batchSize++;
}
}
Console.WriteLine("ReceivedBatch Size: {0}", batchSize);
receivedEvents = await receiver.ReceiveAsync();
}
A Task that will yield a batch of from the partition on which this receiver is created. Returns 'null' if no EventData is present.
Receive a batch of 's from an EventHub partition by allowing wait time on each individual call.
A Task that will yield a batch of from the partition on which this receiver is created. Returns 'null' if no EventData is present.
Sets the to process events.
The used to process events.
Closes and releases resources associated with .
An asynchronous operation
This sender class is a logical representation of sending events to a specific EventHub partition. Do not use this class
if you do not care about sending events to specific partitions, instead use .
Gets the associated with this PartitionSender.
Gets the partition ID for this .
Send to a specific EventHub partition. The target partition is pre-determined when this PartitionSender was created.
This send pattern emphasizes data correlation over general availability and latency.
There are 3 ways to send to EventHubs, each exposed as a method (along with its sendBatch overload):
i. or
ii. or
iii. or
Use this type of send if:
a. The client wants to take direct control of distribution of data across partitions. In this case client is responsible for making sure there is at least one sender per event hub partition.
b. User cannot use partition key as a mean to direct events to specific partition, yet there is a need for data correlation with partitioning scheme.
the to be sent.
A Task that completes when the send operations is done.
the total size of the exceeds a pre-defined limit set by the service. Default is 256k bytes.
Event Hubs service encountered problems during the operation.
Send to a specific EventHub partition. The targeted partition is pre-determined when this PartitionSender was created.
There are 3 ways to send to EventHubs, to understand this particular type of send refer to the overload , which is the same type of send and is used to send single .
Sending a batch of 's is useful in the following cases:
i. Efficient send - sending a batch of maximizes the overall throughput by optimally using the number of sessions created to EventHubs' service.
ii. Sending multiple 's in a Transaction. To acheive ACID properties, the Gateway Service will forward all 's in the batch to a single EventHub partition.
Sample code:
EventHubClient client = EventHubClient.Create("__connectionString__");
PartitionSender senderToPartitionOne = client.CreatePartitionSender("1");
while (true)
{
var events = new List<EventData>();
for (int count = 1; count < 11; count++)
{
var payload = new PayloadEvent(count);
byte[] payloadBytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload));
var sendEvent = new EventData(payloadBytes);
var applicationProperties = new Dictionary<string, string>();
applicationProperties["from"] = "csharpClient";
sendEvent.Properties = applicationProperties;
events.Add(sendEvent);
}
await senderToPartitionOne.SendAsync(events);
Console.WriteLine("Sent Batch... Size: {0}", events.Count);
}
batch of events to send to EventHub
a Task that completes when the send operation is done.
the total size of the exceeds a pre-defined limit set by the service. Default is 256k bytes.
Event Hubs service encountered problems during the operation.
Closes and releases resources for the .
An asynchronous operation
Used as an asynchronous semaphore for internal Event Hubs operations.
Returns a new AsyncLock.
Sets a lock.
An asynchronous operation
Sets a lock, which allows for cancellation, using a .
The which can be used to cancel the lock
An asynchronous operation
Closes and releases any resources associated with the AsyncLock.
Used coordinate lock releases.
Closes and releases resources associated with .
An asynchronous operation
Contract for all client entities with Open-Close/Abort state m/c
main-purpose: closeAll related entities
Gets the client ID.
Gets the for the ClientEntity.
Closes the ClientEntity.
The asynchronous operation
Closes the ClientEntity.
Exception for signaling general communication errors related to messaging operations.
Supported transport types
AMQP over the default TCP transport protocol
AMQP over the Web Sockets transport protocol
EventHubsConnectionStringBuilder can be used to construct a connection string which can establish communication with Event Hubs entities.
It can also be used to perform basic validation on an existing connection string.
A connection string is basically a string consisted of key-value pair separated by ";".
Basic format is "<key>=<value>[;<key>=<value>]" where supported key name are as follow:
Endpoint - the URL that contains the Event Hubs namespace
EntityPath - the path to the Event Hub entity
SharedAccessKeyName - the key name to the corresponding shared access policy rule for the namespace, or entity.
SharedAccessKey - the key for the corresponding shared access policy rule of the namespace or entity.
Sample code:
var connectionStringBuiler = new EventHubsConnectionStringBuilder(
"amqps://EventHubsNamespaceName.servicebus.windows.net",
"EventHubsEntityName", // Event Hub Name
"SharedAccessSignatureKeyName",
"SharedAccessSignatureKey");
string connectionString = connectionStringBuiler.ToString();
Build a connection string consumable by
Fully qualified domain name for Event Hubs. Most likely, {yournamespace}.servicebus.windows.net
Entity path or Event Hub name.
Shared Access Key name
Shared Access Key
Build a connection string consumable by
Fully qualified domain name for Event Hubs. Most likely, {yournamespace}.servicebus.windows.net
Entity path or Event Hub name.
Shared Access Key name
Shared Access Key
Operation timeout for Event Hubs operations
Build a connection string consumable by
Fully qualified domain name for Event Hubs. Most likely, {yournamespace}.servicebus.windows.net
Entity path or Event Hub name.
Shared Access Signature
Operation timeout for Event Hubs operations
ConnectionString format:
Endpoint=sb://namespace_DNS_Name;EntityPath=EVENT_HUB_NAME;SharedAccessKeyName=SHARED_ACCESS_KEY_NAME;SharedAccessKey=SHARED_ACCESS_KEY
Event Hubs ConnectionString
Gets or sets the Event Hubs endpoint.
Get the shared access policy key value from the connection string
Shared Access Signature key
Get the shared access policy owner name from the connection string
Gets or sets the SAS access token.
Shared Access Signature
Get the entity path value from the connection string
OperationTimeout is applied in erroneous situations to notify the caller about the relevant
Transport type for the client connection.
Avaiable options are Amqp and AmqpWebSockets.
Defaults to Amqp if not specified.
Creates a cloned object of the current .
A new
Returns an interoperable connection string that can be used to connect to Event Hubs Namespace
the connection string
Base Exception for various Event Hubs errors.
Returns a new EventHubsException
Specifies whether or not the exception is transient.
Returns a new EventHubsException
Specifies whether or not the exception is transient.
The detailed message exception.
Returns a new EventHubsException
Specifies whether or not the exception is transient.
The inner exception.
Returns a new EventHubsException
Specifies whether or not the exception is transient.
The detailed message exception.
The inner exception.
Gets the message as a formatted string.
A boolean indicating if the exception is a transient error or not.
returns true when user can retry the operation that generated the exception without additional intervention.
Gets the Event Hubs namespace from which the exception occured, if available.
The exception is thrown when the message size exceeds what AMQP allows on the link.
The exception that is thrown when the Event Hub is not found on the namespace.
This exception is thrown if two or more instances connect
to the same partition with different epoch values.
RetryPolicy implementation where the delay between retries will grow in a staggered exponential manner.
RetryPolicy can be set on the client using .
RetryIntervals will be computed using a retryFactor which is a function of deltaBackOff (MaximumBackoff - MinimumBackoff) and MaximumRetryCount
Returns a new RetryExponential retry policy object.
Minimum backoff interval.
Maximum backoff interval.
Maximum retry count.
Represents an abstraction for retrying messaging operations. Users should not
implement this class, and instead should use one of the provided implementations.
Increases the retry count.
The associated with the operation to retry
Resets the retry count to zero.
The associated with the operation to retry
Determines whether or not the exception can be retried.
A bool indicating whether or not the operation can be retried.
Returns the default retry policy, .
Returns the default retry policy, .
Gets the timespan for the next retry operation.
The associated with the operation to retry
The last exception that was thrown
Remaining time for the cumulative timeout
Provides information about a security token such as audience, expiry time, and the string token value.
Creates a new instance of the class.
The token
The expiration time
The audience
Creates a new instance of the class.
The token
The expiration time
Creates a new instance of the class.
The token
Gets the audience of this token.
Gets the expiration time of this token.
Gets the actual token.
The exception that is thrown when a server is busy. Callers should wait a while and retry the operation.
The SharedAccessSignatureTokenProvider generates tokens using a shared access key or existing signature.
Represents 00:00:00 UTC Thursday 1, January 1970.
A WCF SecurityToken that wraps a Shared Access Signature
Formats a string+parameters using CurrentCulture.
Formats a string+parameter using InvariantCulture. This overload avoids allocating an array when there's only one replacement parameter
Formats a string+parameters using InvariantCulture.
This abstract base class can be extended to implement additional token providers.
Gets the scope or permissions associated with the token.
Construct a TokenProvider based on a sharedAccessSignature.
The shared access signature
A TokenProvider initialized with the shared access signature
Construct a TokenProvider based on the provided Key Name and Shared Access Key.
The key name of the corresponding SharedAccessKeyAuthorizationRule.
The key associated with the SharedAccessKeyAuthorizationRule
A TokenProvider initialized with the provided RuleId and Password
Construct a TokenProvider based on the provided Key Name and Shared Access Key.
The key name of the corresponding SharedAccessKeyAuthorizationRule.
The key associated with the SharedAccessKeyAuthorizationRule
The token time to live
A TokenProvider initialized with the provided RuleId and Password
Construct a TokenProvider based on the provided Key Name and Shared Access Key.
The key name of the corresponding SharedAccessKeyAuthorizationRule.
The key associated with the SharedAccessKeyAuthorizationRule
The tokenScope of tokens to request.
A TokenProvider initialized with the provided RuleId and Password
Construct a TokenProvider based on the provided Key Name and Shared Access Key.
The key name of the corresponding SharedAccessKeyAuthorizationRule.
The key associated with the SharedAccessKeyAuthorizationRule
The token time to live
The tokenScope of tokens to request.
A TokenProvider initialized with the provided RuleId and Password
Gets a for the given audience and duration.
The URI which the access token applies to
The request action
The time span that specifies the timeout value for the message that gets the security token
A enum representing the scope of the .
The namespace.
The entity.
A strongly-typed resource class, for looking up localized strings, etc.
Returns the cached ResourceManager instance used by this class.
Overrides the current thread's CurrentUICulture property for all
resource lookups using this strongly typed resource class.
Looks up a localized string similar to The received message (delivery-id:{0}, size:{1} bytes) exceeds the limit ({2} bytes) currently allowed on the link..
Looks up a localized string similar to The argument {0} is null or white space..
Looks up a localized string similar to The argument '{0}' cannot exceed {1} characters..
Looks up a localized string similar to Sending empty {0} is not a valid operation..
Looks up a localized string similar to There are no event data supplied. Please make sure input events are not empty..
Looks up a localized string similar to Serialization operation failed due to unsupported type {0}..
Looks up a localized string similar to The string has an invalid encoding format..
Looks up a localized string similar to The specified partitionKey '{0}' is invalid for partition '{1}'. Do not specify a partitionKey when sending using a PartitionedSender. Instead use EventHubClient.Send..
Looks up a localized string similar to Argument {0} must be a non-negative timeout value. The provided value was {1}..
Looks up a localized string similar to Argument {0} must be a positive timeout value. The provided value was {1}..
Looks up a localized string similar to The provided token does not specify the 'Audience' value..
Looks up a localized string similar to The provided token does not specify the 'ExpiresOn' value..
Looks up a localized string similar to {0} cannot be specified along with {1}. {0} alone should be...
Gets localized string like: Please make sure either all or none of the following arguments are defined: '{0}'.