diff --git a/.ci/windows/versions.json b/.ci/windows/versions.json index 4837d9fff3..555ee49175 100644 --- a/.ci/windows/versions.json +++ b/.ci/windows/versions.json @@ -1,4 +1,4 @@ { - "erlang": "26.1.2", + "erlang": "26.2.1", "rabbitmq": "3.12.10" } diff --git a/.editorconfig b/.editorconfig index e5fa3068ff..347225996c 100644 --- a/.editorconfig +++ b/.editorconfig @@ -158,8 +158,17 @@ csharp_space_between_parentheses = false csharp_space_between_square_brackets = false # Analyzers +dotnet_code_quality.api_surface = public dotnet_code_quality.ca1802.api_surface = private, internal +dotnet_public_api_analyzer.require_api_files = true + +dotnet_diagnostic.RS0026.severity = none +dotnet_diagnostic.RS0027.severity = none +dotnet_diagnostic.RS0036.severity = none +dotnet_diagnostic.RS0041.severity = none +dotnet_diagnostic.RS0051.severity = error + # C++ Files [*.{cpp,h,in}] curly_bracket_next_line = true diff --git a/.github/workflows/build-test.yaml b/.github/workflows/build-test.yaml index 38b1c51317..8bf087255f 100644 --- a/.github/workflows/build-test.yaml +++ b/.github/workflows/build-test.yaml @@ -5,8 +5,7 @@ on: jobs: build-win32: - name: build, unit test on windows-latest - runs-on: windows-latest + runs-on: windows-2019 # https://github.com/NuGet/Home/issues/11548 env: NUGET_CERT_REVOCATION_MODE: offline @@ -43,9 +42,8 @@ jobs: projects/Test/SequentialIntegration/bin projects/RabbitMQ.*/bin integration-win32: - name: integration test on windows-latest needs: build-win32 - runs-on: windows-latest + runs-on: windows-2019 # https://github.com/NuGet/Home/issues/11548 env: NUGET_CERT_REVOCATION_MODE: offline @@ -80,9 +78,8 @@ jobs: name: rabbitmq-logs-integration-win32 path: ~/AppData/Roaming/RabbitMQ/log/ sequential-integration-win32: - name: sequential integration test on windows-latest needs: build-win32 - runs-on: windows-latest + runs-on: windows-2019 # https://github.com/NuGet/Home/issues/11548 env: NUGET_CERT_REVOCATION_MODE: offline @@ -116,7 +113,6 @@ jobs: path: ~/AppData/Roaming/RabbitMQ/log/ build-ubuntu: - name: build, unit test on ubuntu-latest runs-on: ubuntu-latest steps: - name: Clone repository @@ -155,7 +151,6 @@ jobs: projects/Test/SequentialIntegration/bin projects/RabbitMQ.*/bin integration-ubuntu: - name: integration test on ubuntu-latest needs: build-ubuntu runs-on: ubuntu-latest steps: @@ -195,7 +190,6 @@ jobs: name: rabbitmq-logs-integration-ubuntu path: ${{ github.workspace }}/.ci/ubuntu/log/ sequential-integration-ubuntu: - name: sequential integration test on ubuntu-latest needs: build-ubuntu runs-on: ubuntu-latest steps: diff --git a/projects/RabbitMQ.Client.OAuth2/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client.OAuth2/PublicAPI.Shipped.txt new file mode 100644 index 0000000000..e69de29bb2 diff --git a/projects/RabbitMQ.Client.OAuth2/PublicAPI.Unshipped.txt b/projects/RabbitMQ.Client.OAuth2/PublicAPI.Unshipped.txt new file mode 100644 index 0000000000..cd426f421f --- /dev/null +++ b/projects/RabbitMQ.Client.OAuth2/PublicAPI.Unshipped.txt @@ -0,0 +1,36 @@ +RabbitMQ.Client.OAuth2.IOAuth2Client +RabbitMQ.Client.OAuth2.IOAuth2Client.RefreshToken(RabbitMQ.Client.OAuth2.IToken token) -> RabbitMQ.Client.OAuth2.IToken +RabbitMQ.Client.OAuth2.IOAuth2Client.RequestToken() -> RabbitMQ.Client.OAuth2.IToken +RabbitMQ.Client.OAuth2.IToken +RabbitMQ.Client.OAuth2.IToken.AccessToken.get -> string +RabbitMQ.Client.OAuth2.IToken.ExpiresIn.get -> System.TimeSpan +RabbitMQ.Client.OAuth2.IToken.hasExpired.get -> bool +RabbitMQ.Client.OAuth2.IToken.RefreshToken.get -> string +RabbitMQ.Client.OAuth2.JsonToken +RabbitMQ.Client.OAuth2.JsonToken.access_token.get -> string +RabbitMQ.Client.OAuth2.JsonToken.access_token.set -> void +RabbitMQ.Client.OAuth2.JsonToken.expires_in.get -> long +RabbitMQ.Client.OAuth2.JsonToken.expires_in.set -> void +RabbitMQ.Client.OAuth2.JsonToken.JsonToken() -> void +RabbitMQ.Client.OAuth2.JsonToken.JsonToken(string access_token, string refresh_token, long expires_in) -> void +RabbitMQ.Client.OAuth2.JsonToken.JsonToken(string access_token, string refresh_token, System.TimeSpan expires_in_span) -> void +RabbitMQ.Client.OAuth2.JsonToken.refresh_token.get -> string +RabbitMQ.Client.OAuth2.JsonToken.refresh_token.set -> void +RabbitMQ.Client.OAuth2.OAuth2ClientBuilder +RabbitMQ.Client.OAuth2.OAuth2ClientBuilder.AddRequestParameter(string param, string paramValue) -> RabbitMQ.Client.OAuth2.OAuth2ClientBuilder +RabbitMQ.Client.OAuth2.OAuth2ClientBuilder.Build() -> RabbitMQ.Client.OAuth2.IOAuth2Client +RabbitMQ.Client.OAuth2.OAuth2ClientBuilder.OAuth2ClientBuilder(string clientId, string clientSecret, System.Uri tokenEndpoint) -> void +RabbitMQ.Client.OAuth2.OAuth2ClientBuilder.SetHttpClientHandler(System.Net.Http.HttpClientHandler handler) -> RabbitMQ.Client.OAuth2.OAuth2ClientBuilder +RabbitMQ.Client.OAuth2.OAuth2ClientBuilder.SetScope(string scope) -> RabbitMQ.Client.OAuth2.OAuth2ClientBuilder +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.Name.get -> string +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.OAuth2ClientCredentialsProvider(string name, RabbitMQ.Client.OAuth2.IOAuth2Client oAuth2Client) -> void +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.Password.get -> string +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.Refresh() -> void +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.UserName.get -> string +RabbitMQ.Client.OAuth2.OAuth2ClientCredentialsProvider.ValidUntil.get -> System.TimeSpan? +RabbitMQ.Client.OAuth2.Token +RabbitMQ.Client.OAuth2.Token.AccessToken.get -> string +RabbitMQ.Client.OAuth2.Token.ExpiresIn.get -> System.TimeSpan +RabbitMQ.Client.OAuth2.Token.RefreshToken.get -> string +RabbitMQ.Client.OAuth2.Token.Token(RabbitMQ.Client.OAuth2.JsonToken json) -> void \ No newline at end of file diff --git a/projects/RabbitMQ.Client.OAuth2/RabbitMQ.Client.OAuth2.csproj b/projects/RabbitMQ.Client.OAuth2/RabbitMQ.Client.OAuth2.csproj index f8d34a80be..77f6d28b21 100644 --- a/projects/RabbitMQ.Client.OAuth2/RabbitMQ.Client.OAuth2.csproj +++ b/projects/RabbitMQ.Client.OAuth2/RabbitMQ.Client.OAuth2.csproj @@ -54,6 +54,7 @@ + diff --git a/projects/RabbitMQ.Client/PublicAPI.Shipped.txt b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt new file mode 100644 index 0000000000..7dc5c58110 --- /dev/null +++ b/projects/RabbitMQ.Client/PublicAPI.Shipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt b/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt new file mode 100644 index 0000000000..239e593250 --- /dev/null +++ b/projects/RabbitMQ.Client/PublicAPI.Unshipped.txt @@ -0,0 +1,1035 @@ +abstract RabbitMQ.Client.Exceptions.ProtocolException.ReplyCode.get -> ushort +const RabbitMQ.Client.AmqpTcpEndpoint.DefaultAmqpSslPort = 5671 -> int +const RabbitMQ.Client.AmqpTcpEndpoint.UseDefaultPort = -1 -> int +const RabbitMQ.Client.ConnectionFactory.DefaultChannelMax = 2047 -> ushort +const RabbitMQ.Client.ConnectionFactory.DefaultFrameMax = 0 -> uint +const RabbitMQ.Client.ConnectionFactory.DefaultMaxMessageSize = 134217728 -> uint +const RabbitMQ.Client.ConnectionFactory.DefaultPass = "guest" -> string +const RabbitMQ.Client.ConnectionFactory.DefaultUser = "guest" -> string +const RabbitMQ.Client.ConnectionFactory.DefaultVHost = "/" -> string +const RabbitMQ.Client.ConnectionFactory.MaximumMaxMessageSize = 536870912 -> uint +const RabbitMQ.Client.Constants.AccessRefused = 403 -> int +const RabbitMQ.Client.Constants.ChannelError = 504 -> int +const RabbitMQ.Client.Constants.CommandInvalid = 503 -> int +const RabbitMQ.Client.Constants.ConnectionForced = 320 -> int +const RabbitMQ.Client.Constants.ContentTooLarge = 311 -> int +const RabbitMQ.Client.Constants.FrameBody = 3 -> int +const RabbitMQ.Client.Constants.FrameEnd = 206 -> int +const RabbitMQ.Client.Constants.FrameError = 501 -> int +const RabbitMQ.Client.Constants.FrameHeader = 2 -> int +const RabbitMQ.Client.Constants.FrameHeartbeat = 8 -> int +const RabbitMQ.Client.Constants.FrameMethod = 1 -> int +const RabbitMQ.Client.Constants.FrameMinSize = 4096 -> int +const RabbitMQ.Client.Constants.InternalError = 541 -> int +const RabbitMQ.Client.Constants.InvalidPath = 402 -> int +const RabbitMQ.Client.Constants.NoConsumers = 313 -> int +const RabbitMQ.Client.Constants.NoRoute = 312 -> int +const RabbitMQ.Client.Constants.NotAllowed = 530 -> int +const RabbitMQ.Client.Constants.NotFound = 404 -> int +const RabbitMQ.Client.Constants.NotImplemented = 540 -> int +const RabbitMQ.Client.Constants.PreconditionFailed = 406 -> int +const RabbitMQ.Client.Constants.ReplySuccess = 200 -> int +const RabbitMQ.Client.Constants.ResourceError = 506 -> int +const RabbitMQ.Client.Constants.ResourceLocked = 405 -> int +const RabbitMQ.Client.Constants.SyntaxError = 502 -> int +const RabbitMQ.Client.Constants.UnexpectedFrame = 505 -> int +const RabbitMQ.Client.ExchangeType.Direct = "direct" -> string +const RabbitMQ.Client.ExchangeType.Fanout = "fanout" -> string +const RabbitMQ.Client.ExchangeType.Headers = "headers" -> string +const RabbitMQ.Client.ExchangeType.Topic = "topic" -> string +const RabbitMQ.Client.Headers.AlternateExchange = "alternate-exchange" -> string +const RabbitMQ.Client.Headers.XDeadLetterExchange = "x-dead-letter-exchange" -> string +const RabbitMQ.Client.Headers.XDeadLetterRoutingKey = "x-dead-letter-routing-key" -> string +const RabbitMQ.Client.Headers.XExpires = "x-expires" -> string +const RabbitMQ.Client.Headers.XMaxAge = "x-max-age" -> string +const RabbitMQ.Client.Headers.XMaxLength = "x-max-length" -> string +const RabbitMQ.Client.Headers.XMaxLengthInBytes = "x-max-length-bytes" -> string +const RabbitMQ.Client.Headers.XMaxPriority = "x-max-priority" -> string +const RabbitMQ.Client.Headers.XMessageTTL = "x-message-ttl" -> string +const RabbitMQ.Client.Headers.XOverflow = "x-overflow" -> string +const RabbitMQ.Client.Headers.XPriority = "x-priority" -> string +const RabbitMQ.Client.Headers.XQueueMode = "x-queue-mode" -> string +const RabbitMQ.Client.Headers.XQueueType = "x-queue-type" -> string +const RabbitMQ.Client.Headers.XQuorumInitialGroupSize = "x-quorum-initial-group-size" -> string +const RabbitMQ.Client.Headers.XSingleActiveConsumer = "x-single-active-consumer" -> string +const RabbitMQ.Client.Headers.XStreamMaxSegmentSizeInBytes = "x-stream-max-segment-size-bytes" -> string +const RabbitMQ.Client.Headers.XStreamOffset = "x-stream-offset" -> string +override RabbitMQ.Client.AmqpTcpEndpoint.Equals(object obj) -> bool +override RabbitMQ.Client.AmqpTcpEndpoint.GetHashCode() -> int +override RabbitMQ.Client.AmqpTcpEndpoint.ToString() -> string +override RabbitMQ.Client.AmqpTimestamp.Equals(object obj) -> bool +override RabbitMQ.Client.AmqpTimestamp.GetHashCode() -> int +override RabbitMQ.Client.AmqpTimestamp.ToString() -> string +override RabbitMQ.Client.Events.AsyncEventingBasicConsumer.HandleBasicCancelOk(string consumerTag) -> System.Threading.Tasks.Task +override RabbitMQ.Client.Events.AsyncEventingBasicConsumer.HandleBasicConsumeOk(string consumerTag) -> System.Threading.Tasks.Task +override RabbitMQ.Client.Events.AsyncEventingBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> System.Threading.Tasks.Task +override RabbitMQ.Client.Events.AsyncEventingBasicConsumer.HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> System.Threading.Tasks.Task +override RabbitMQ.Client.Events.EventingBasicConsumer.HandleBasicCancelOk(string consumerTag) -> void +override RabbitMQ.Client.Events.EventingBasicConsumer.HandleBasicConsumeOk(string consumerTag) -> void +override RabbitMQ.Client.Events.EventingBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> void +override RabbitMQ.Client.Events.EventingBasicConsumer.HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> void +override RabbitMQ.Client.Exceptions.MalformedFrameException.ReplyCode.get -> ushort +override RabbitMQ.Client.Exceptions.SyntaxErrorException.ReplyCode.get -> ushort +override RabbitMQ.Client.Exceptions.UnexpectedFrameException.ReplyCode.get -> ushort +override RabbitMQ.Client.Exceptions.UnknownClassOrMethodException.ReplyCode.get -> ushort +override RabbitMQ.Client.Exceptions.UnknownClassOrMethodException.ToString() -> string +override RabbitMQ.Client.Logging.RabbitMqExceptionDetail.ToString() -> string +override RabbitMQ.Client.PublicationAddress.ToString() -> string +override RabbitMQ.Client.ShutdownEventArgs.ToString() -> string +override RabbitMQ.Client.ShutdownReportEntry.ToString() -> string +RabbitMQ.Client.AmqpTcpEndpoint +RabbitMQ.Client.AmqpTcpEndpoint.AddressFamily.get -> System.Net.Sockets.AddressFamily +RabbitMQ.Client.AmqpTcpEndpoint.AddressFamily.set -> void +RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint() -> void +RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint(string hostName, int portOrMinusOne = -1) -> void +RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint(string hostName, int portOrMinusOne, RabbitMQ.Client.SslOption ssl) -> void +RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint(string hostName, int portOrMinusOne, RabbitMQ.Client.SslOption ssl, uint maxMessageSize) -> void +RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint(System.Uri uri) -> void +RabbitMQ.Client.AmqpTcpEndpoint.AmqpTcpEndpoint(System.Uri uri, RabbitMQ.Client.SslOption ssl) -> void +RabbitMQ.Client.AmqpTcpEndpoint.Clone() -> object +RabbitMQ.Client.AmqpTcpEndpoint.CloneWithHostname(string hostname) -> RabbitMQ.Client.AmqpTcpEndpoint +RabbitMQ.Client.AmqpTcpEndpoint.HostName.get -> string +RabbitMQ.Client.AmqpTcpEndpoint.HostName.set -> void +RabbitMQ.Client.AmqpTcpEndpoint.MaxMessageSize.get -> uint +RabbitMQ.Client.AmqpTcpEndpoint.Port.get -> int +RabbitMQ.Client.AmqpTcpEndpoint.Port.set -> void +RabbitMQ.Client.AmqpTcpEndpoint.Protocol.get -> RabbitMQ.Client.IProtocol +RabbitMQ.Client.AmqpTcpEndpoint.Ssl.get -> RabbitMQ.Client.SslOption +RabbitMQ.Client.AmqpTcpEndpoint.Ssl.set -> void +RabbitMQ.Client.AmqpTimestamp +RabbitMQ.Client.AmqpTimestamp.AmqpTimestamp() -> void +RabbitMQ.Client.AmqpTimestamp.AmqpTimestamp(long unixTime) -> void +RabbitMQ.Client.AmqpTimestamp.Equals(RabbitMQ.Client.AmqpTimestamp other) -> bool +RabbitMQ.Client.AsyncDefaultBasicConsumer +RabbitMQ.Client.AsyncDefaultBasicConsumer.AsyncDefaultBasicConsumer() -> void +RabbitMQ.Client.AsyncDefaultBasicConsumer.AsyncDefaultBasicConsumer(RabbitMQ.Client.IChannel channel) -> void +RabbitMQ.Client.AsyncDefaultBasicConsumer.Channel.get -> RabbitMQ.Client.IChannel +RabbitMQ.Client.AsyncDefaultBasicConsumer.Channel.set -> void +RabbitMQ.Client.AsyncDefaultBasicConsumer.ConsumerCancelled -> RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.AsyncDefaultBasicConsumer.ConsumerTags.get -> string[] +RabbitMQ.Client.AsyncDefaultBasicConsumer.IsRunning.get -> bool +RabbitMQ.Client.AsyncDefaultBasicConsumer.IsRunning.set -> void +RabbitMQ.Client.AsyncDefaultBasicConsumer.ShutdownReason.get -> RabbitMQ.Client.ShutdownEventArgs +RabbitMQ.Client.AsyncDefaultBasicConsumer.ShutdownReason.set -> void +RabbitMQ.Client.BasicCredentialsProvider +RabbitMQ.Client.BasicCredentialsProvider.BasicCredentialsProvider(string name, string userName, string password) -> void +RabbitMQ.Client.BasicCredentialsProvider.Name.get -> string +RabbitMQ.Client.BasicCredentialsProvider.Password.get -> string +RabbitMQ.Client.BasicCredentialsProvider.Refresh() -> void +RabbitMQ.Client.BasicCredentialsProvider.UserName.get -> string +RabbitMQ.Client.BasicCredentialsProvider.ValidUntil.get -> System.TimeSpan? +RabbitMQ.Client.BasicGetResult +RabbitMQ.Client.BasicGetResult.BasicGetResult(ulong deliveryTag, bool redelivered, string exchange, string routingKey, uint messageCount, in RabbitMQ.Client.ReadOnlyBasicProperties basicProperties, System.ReadOnlyMemory body) -> void +RabbitMQ.Client.BasicProperties +RabbitMQ.Client.BasicProperties.AppId.get -> string +RabbitMQ.Client.BasicProperties.AppId.set -> void +RabbitMQ.Client.BasicProperties.BasicProperties() -> void +RabbitMQ.Client.BasicProperties.BasicProperties(in RabbitMQ.Client.ReadOnlyBasicProperties input) -> void +RabbitMQ.Client.BasicProperties.ClearAppId() -> void +RabbitMQ.Client.BasicProperties.ClearClusterId() -> void +RabbitMQ.Client.BasicProperties.ClearContentEncoding() -> void +RabbitMQ.Client.BasicProperties.ClearContentType() -> void +RabbitMQ.Client.BasicProperties.ClearCorrelationId() -> void +RabbitMQ.Client.BasicProperties.ClearDeliveryMode() -> void +RabbitMQ.Client.BasicProperties.ClearExpiration() -> void +RabbitMQ.Client.BasicProperties.ClearHeaders() -> void +RabbitMQ.Client.BasicProperties.ClearMessageId() -> void +RabbitMQ.Client.BasicProperties.ClearPriority() -> void +RabbitMQ.Client.BasicProperties.ClearReplyTo() -> void +RabbitMQ.Client.BasicProperties.ClearTimestamp() -> void +RabbitMQ.Client.BasicProperties.ClearType() -> void +RabbitMQ.Client.BasicProperties.ClearUserId() -> void +RabbitMQ.Client.BasicProperties.ClusterId.get -> string +RabbitMQ.Client.BasicProperties.ClusterId.set -> void +RabbitMQ.Client.BasicProperties.ContentEncoding.get -> string +RabbitMQ.Client.BasicProperties.ContentEncoding.set -> void +RabbitMQ.Client.BasicProperties.ContentType.get -> string +RabbitMQ.Client.BasicProperties.ContentType.set -> void +RabbitMQ.Client.BasicProperties.CorrelationId.get -> string +RabbitMQ.Client.BasicProperties.CorrelationId.set -> void +RabbitMQ.Client.BasicProperties.DeliveryMode.get -> RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.BasicProperties.DeliveryMode.set -> void +RabbitMQ.Client.BasicProperties.Expiration.get -> string +RabbitMQ.Client.BasicProperties.Expiration.set -> void +RabbitMQ.Client.BasicProperties.Headers.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.BasicProperties.Headers.set -> void +RabbitMQ.Client.BasicProperties.IsAppIdPresent() -> bool +RabbitMQ.Client.BasicProperties.IsClusterIdPresent() -> bool +RabbitMQ.Client.BasicProperties.IsContentEncodingPresent() -> bool +RabbitMQ.Client.BasicProperties.IsContentTypePresent() -> bool +RabbitMQ.Client.BasicProperties.IsCorrelationIdPresent() -> bool +RabbitMQ.Client.BasicProperties.IsDeliveryModePresent() -> bool +RabbitMQ.Client.BasicProperties.IsExpirationPresent() -> bool +RabbitMQ.Client.BasicProperties.IsHeadersPresent() -> bool +RabbitMQ.Client.BasicProperties.IsMessageIdPresent() -> bool +RabbitMQ.Client.BasicProperties.IsPriorityPresent() -> bool +RabbitMQ.Client.BasicProperties.IsReplyToPresent() -> bool +RabbitMQ.Client.BasicProperties.IsTimestampPresent() -> bool +RabbitMQ.Client.BasicProperties.IsTypePresent() -> bool +RabbitMQ.Client.BasicProperties.IsUserIdPresent() -> bool +RabbitMQ.Client.BasicProperties.MessageId.get -> string +RabbitMQ.Client.BasicProperties.MessageId.set -> void +RabbitMQ.Client.BasicProperties.Persistent.get -> bool +RabbitMQ.Client.BasicProperties.Persistent.set -> void +RabbitMQ.Client.BasicProperties.Priority.get -> byte +RabbitMQ.Client.BasicProperties.Priority.set -> void +RabbitMQ.Client.BasicProperties.ReplyTo.get -> string +RabbitMQ.Client.BasicProperties.ReplyTo.set -> void +RabbitMQ.Client.BasicProperties.ReplyToAddress.get -> RabbitMQ.Client.PublicationAddress +RabbitMQ.Client.BasicProperties.ReplyToAddress.set -> void +RabbitMQ.Client.BasicProperties.Timestamp.get -> RabbitMQ.Client.AmqpTimestamp +RabbitMQ.Client.BasicProperties.Timestamp.set -> void +RabbitMQ.Client.BasicProperties.Type.get -> string +RabbitMQ.Client.BasicProperties.Type.set -> void +RabbitMQ.Client.BasicProperties.UserId.get -> string +RabbitMQ.Client.BasicProperties.UserId.set -> void +RabbitMQ.Client.BinaryTableValue +RabbitMQ.Client.BinaryTableValue.BinaryTableValue() -> void +RabbitMQ.Client.BinaryTableValue.BinaryTableValue(byte[] bytes) -> void +RabbitMQ.Client.BinaryTableValue.Bytes.get -> byte[] +RabbitMQ.Client.BinaryTableValue.Bytes.set -> void +RabbitMQ.Client.CachedString +RabbitMQ.Client.CachedString.CachedString(string value) -> void +RabbitMQ.Client.CachedString.CachedString(string value, System.ReadOnlyMemory bytes) -> void +RabbitMQ.Client.CachedString.CachedString(System.ReadOnlyMemory bytes) -> void +RabbitMQ.Client.ConnectionConfig +RabbitMQ.Client.ConnectionConfig.CredentialsProvider -> RabbitMQ.Client.ICredentialsProvider +RabbitMQ.Client.ConnectionConfig.CredentialsRefresher -> RabbitMQ.Client.ICredentialsRefresher +RabbitMQ.Client.ConnectionFactory +RabbitMQ.Client.ConnectionFactory.AmqpUriSslProtocols.get -> System.Security.Authentication.SslProtocols +RabbitMQ.Client.ConnectionFactory.AmqpUriSslProtocols.set -> void +RabbitMQ.Client.ConnectionFactory.AuthMechanismFactory(System.Collections.Generic.IEnumerable argServerMechanismNames) -> RabbitMQ.Client.IAuthMechanismFactory +RabbitMQ.Client.ConnectionFactory.AuthMechanisms.get -> System.Collections.Generic.IEnumerable +RabbitMQ.Client.ConnectionFactory.AuthMechanisms.set -> void +RabbitMQ.Client.ConnectionFactory.AutomaticRecoveryEnabled.get -> bool +RabbitMQ.Client.ConnectionFactory.AutomaticRecoveryEnabled.set -> void +RabbitMQ.Client.ConnectionFactory.ClientProperties.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.ConnectionFactory.ClientProperties.set -> void +RabbitMQ.Client.ConnectionFactory.ClientProvidedName.get -> string +RabbitMQ.Client.ConnectionFactory.ClientProvidedName.set -> void +RabbitMQ.Client.ConnectionFactory.ConnectionFactory() -> void +RabbitMQ.Client.ConnectionFactory.ConsumerDispatchConcurrency.get -> int +RabbitMQ.Client.ConnectionFactory.ConsumerDispatchConcurrency.set -> void +RabbitMQ.Client.ConnectionFactory.ContinuationTimeout.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.ContinuationTimeout.set -> void +RabbitMQ.Client.ConnectionFactory.CreateConnection() -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnection(RabbitMQ.Client.IEndpointResolver endpointResolver, string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnection(string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable endpoints) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable hostnames) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(RabbitMQ.Client.IEndpointResolver endpointResolver, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CreateConnectionAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.ConnectionFactory.CredentialsProvider.get -> RabbitMQ.Client.ICredentialsProvider +RabbitMQ.Client.ConnectionFactory.CredentialsProvider.set -> void +RabbitMQ.Client.ConnectionFactory.CredentialsRefresher.get -> RabbitMQ.Client.ICredentialsRefresher +RabbitMQ.Client.ConnectionFactory.CredentialsRefresher.set -> void +RabbitMQ.Client.ConnectionFactory.DispatchConsumersAsync.get -> bool +RabbitMQ.Client.ConnectionFactory.DispatchConsumersAsync.set -> void +RabbitMQ.Client.ConnectionFactory.Endpoint.get -> RabbitMQ.Client.AmqpTcpEndpoint +RabbitMQ.Client.ConnectionFactory.Endpoint.set -> void +RabbitMQ.Client.ConnectionFactory.EndpointResolverFactory.get -> System.Func, RabbitMQ.Client.IEndpointResolver> +RabbitMQ.Client.ConnectionFactory.EndpointResolverFactory.set -> void +RabbitMQ.Client.ConnectionFactory.HandshakeContinuationTimeout.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.HandshakeContinuationTimeout.set -> void +RabbitMQ.Client.ConnectionFactory.HostName.get -> string +RabbitMQ.Client.ConnectionFactory.HostName.set -> void +RabbitMQ.Client.ConnectionFactory.MaxMessageSize.get -> uint +RabbitMQ.Client.ConnectionFactory.MaxMessageSize.set -> void +RabbitMQ.Client.ConnectionFactory.NetworkRecoveryInterval.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.NetworkRecoveryInterval.set -> void +RabbitMQ.Client.ConnectionFactory.Password.get -> string +RabbitMQ.Client.ConnectionFactory.Password.set -> void +RabbitMQ.Client.ConnectionFactory.Port.get -> int +RabbitMQ.Client.ConnectionFactory.Port.set -> void +RabbitMQ.Client.ConnectionFactory.RequestedChannelMax.get -> ushort +RabbitMQ.Client.ConnectionFactory.RequestedChannelMax.set -> void +RabbitMQ.Client.ConnectionFactory.RequestedConnectionTimeout.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.RequestedConnectionTimeout.set -> void +RabbitMQ.Client.ConnectionFactory.RequestedFrameMax.get -> uint +RabbitMQ.Client.ConnectionFactory.RequestedFrameMax.set -> void +RabbitMQ.Client.ConnectionFactory.RequestedHeartbeat.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.RequestedHeartbeat.set -> void +RabbitMQ.Client.ConnectionFactory.SocketReadTimeout.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.SocketReadTimeout.set -> void +RabbitMQ.Client.ConnectionFactory.SocketWriteTimeout.get -> System.TimeSpan +RabbitMQ.Client.ConnectionFactory.SocketWriteTimeout.set -> void +RabbitMQ.Client.ConnectionFactory.Ssl.get -> RabbitMQ.Client.SslOption +RabbitMQ.Client.ConnectionFactory.Ssl.set -> void +RabbitMQ.Client.ConnectionFactory.TopologyRecoveryEnabled.get -> bool +RabbitMQ.Client.ConnectionFactory.TopologyRecoveryEnabled.set -> void +RabbitMQ.Client.ConnectionFactory.TopologyRecoveryExceptionHandler.get -> RabbitMQ.Client.TopologyRecoveryExceptionHandler +RabbitMQ.Client.ConnectionFactory.TopologyRecoveryExceptionHandler.set -> void +RabbitMQ.Client.ConnectionFactory.TopologyRecoveryFilter.get -> RabbitMQ.Client.TopologyRecoveryFilter +RabbitMQ.Client.ConnectionFactory.TopologyRecoveryFilter.set -> void +RabbitMQ.Client.ConnectionFactory.Uri.get -> System.Uri +RabbitMQ.Client.ConnectionFactory.Uri.set -> void +RabbitMQ.Client.ConnectionFactory.UserName.get -> string +RabbitMQ.Client.ConnectionFactory.UserName.set -> void +RabbitMQ.Client.ConnectionFactory.VirtualHost.get -> string +RabbitMQ.Client.ConnectionFactory.VirtualHost.set -> void +RabbitMQ.Client.ConnectionFactoryBase +RabbitMQ.Client.ConnectionFactoryBase.ConnectionFactoryBase() -> void +RabbitMQ.Client.ConnectionFactoryBase.SocketFactory -> System.Func +RabbitMQ.Client.Constants +RabbitMQ.Client.DefaultBasicConsumer +RabbitMQ.Client.DefaultBasicConsumer.Channel.get -> RabbitMQ.Client.IChannel +RabbitMQ.Client.DefaultBasicConsumer.Channel.set -> void +RabbitMQ.Client.DefaultBasicConsumer.ConsumerCancelled -> System.EventHandler +RabbitMQ.Client.DefaultBasicConsumer.ConsumerTags.get -> string[] +RabbitMQ.Client.DefaultBasicConsumer.DefaultBasicConsumer() -> void +RabbitMQ.Client.DefaultBasicConsumer.DefaultBasicConsumer(RabbitMQ.Client.IChannel channel) -> void +RabbitMQ.Client.DefaultBasicConsumer.IsRunning.get -> bool +RabbitMQ.Client.DefaultBasicConsumer.IsRunning.set -> void +RabbitMQ.Client.DefaultBasicConsumer.ShutdownReason.get -> RabbitMQ.Client.ShutdownEventArgs +RabbitMQ.Client.DefaultBasicConsumer.ShutdownReason.set -> void +RabbitMQ.Client.DefaultEndpointResolver +RabbitMQ.Client.DefaultEndpointResolver.All() -> System.Collections.Generic.IEnumerable +RabbitMQ.Client.DefaultEndpointResolver.DefaultEndpointResolver(System.Collections.Generic.IEnumerable tcpEndpoints) -> void +RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.DeliveryModes.Persistent = 2 -> RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.DeliveryModes.Transient = 1 -> RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.EndpointResolverExtensions +RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.Events.AsyncEventingBasicConsumer +RabbitMQ.Client.Events.AsyncEventingBasicConsumer.AsyncEventingBasicConsumer(RabbitMQ.Client.IChannel channel) -> void +RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Received -> RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Registered -> RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Shutdown -> RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.Events.AsyncEventingBasicConsumer.Unregistered -> RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.Events.BaseExceptionEventArgs +RabbitMQ.Client.Events.BaseExceptionEventArgs.BaseExceptionEventArgs(System.Collections.Generic.IDictionary detail, System.Exception exception) -> void +RabbitMQ.Client.Events.BasicAckEventArgs +RabbitMQ.Client.Events.BasicAckEventArgs.BasicAckEventArgs(ulong deliveryTag, bool multiple) -> void +RabbitMQ.Client.Events.BasicDeliverEventArgs +RabbitMQ.Client.Events.BasicDeliverEventArgs.BasicDeliverEventArgs(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> void +RabbitMQ.Client.Events.BasicNackEventArgs +RabbitMQ.Client.Events.BasicNackEventArgs.BasicNackEventArgs(ulong deliveryTag, bool multiple, bool requeue) -> void +RabbitMQ.Client.Events.BasicReturnEventArgs +RabbitMQ.Client.Events.BasicReturnEventArgs.BasicReturnEventArgs(ushort replyCode, string replyText, string exchange, string routingKey, RabbitMQ.Client.ReadOnlyBasicProperties basicProperties, System.ReadOnlyMemory body) -> void +RabbitMQ.Client.Events.CallbackExceptionEventArgs +RabbitMQ.Client.Events.CallbackExceptionEventArgs.CallbackExceptionEventArgs(System.Collections.Generic.IDictionary detail, System.Exception exception) -> void +RabbitMQ.Client.Events.ConnectionBlockedEventArgs +RabbitMQ.Client.Events.ConnectionBlockedEventArgs.ConnectionBlockedEventArgs(string reason) -> void +RabbitMQ.Client.Events.ConnectionRecoveryErrorEventArgs +RabbitMQ.Client.Events.ConnectionRecoveryErrorEventArgs.ConnectionRecoveryErrorEventArgs(System.Exception ex) -> void +RabbitMQ.Client.Events.ConsumerEventArgs +RabbitMQ.Client.Events.ConsumerEventArgs.ConsumerEventArgs(string[] consumerTags) -> void +RabbitMQ.Client.Events.ConsumerTagChangedAfterRecoveryEventArgs +RabbitMQ.Client.Events.ConsumerTagChangedAfterRecoveryEventArgs.ConsumerTagChangedAfterRecoveryEventArgs(string tagBefore, string tagAfter) -> void +RabbitMQ.Client.Events.EventingBasicConsumer +RabbitMQ.Client.Events.EventingBasicConsumer.EventingBasicConsumer(RabbitMQ.Client.IChannel channel) -> void +RabbitMQ.Client.Events.EventingBasicConsumer.Received -> System.EventHandler +RabbitMQ.Client.Events.EventingBasicConsumer.Registered -> System.EventHandler +RabbitMQ.Client.Events.EventingBasicConsumer.Shutdown -> System.EventHandler +RabbitMQ.Client.Events.EventingBasicConsumer.Unregistered -> System.EventHandler +RabbitMQ.Client.Events.FlowControlEventArgs +RabbitMQ.Client.Events.FlowControlEventArgs.FlowControlEventArgs(bool active) -> void +RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs +RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.QueueNameChangedAfterRecoveryEventArgs(string nameBefore, string nameAfter) -> void +RabbitMQ.Client.Events.RecoveringConsumerEventArgs +RabbitMQ.Client.Events.RecoveringConsumerEventArgs.ConsumerArguments.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.Events.RecoveringConsumerEventArgs.ConsumerTag.get -> string +RabbitMQ.Client.Events.RecoveringConsumerEventArgs.RecoveringConsumerEventArgs(string consumerTag, System.Collections.Generic.IDictionary consumerArguments) -> void +RabbitMQ.Client.Exceptions.AlreadyClosedException +RabbitMQ.Client.Exceptions.AlreadyClosedException.AlreadyClosedException(RabbitMQ.Client.ShutdownEventArgs reason) -> void +RabbitMQ.Client.Exceptions.AuthenticationFailureException +RabbitMQ.Client.Exceptions.AuthenticationFailureException.AuthenticationFailureException(string msg) -> void +RabbitMQ.Client.Exceptions.BrokerUnreachableException +RabbitMQ.Client.Exceptions.BrokerUnreachableException.BrokerUnreachableException(System.Exception Inner) -> void +RabbitMQ.Client.Exceptions.ChannelAllocationException +RabbitMQ.Client.Exceptions.ChannelAllocationException.Channel.get -> int +RabbitMQ.Client.Exceptions.ChannelAllocationException.ChannelAllocationException() -> void +RabbitMQ.Client.Exceptions.ChannelAllocationException.ChannelAllocationException(int channel) -> void +RabbitMQ.Client.Exceptions.ConnectFailureException +RabbitMQ.Client.Exceptions.ConnectFailureException.ConnectFailureException(string msg, System.Exception inner) -> void +RabbitMQ.Client.Exceptions.HardProtocolException +RabbitMQ.Client.Exceptions.HardProtocolException.CanShutdownCleanly.get -> bool +RabbitMQ.Client.Exceptions.HardProtocolException.HardProtocolException(string message) -> void +RabbitMQ.Client.Exceptions.HardProtocolException.HardProtocolException(string message, bool canShutdownCleanly) -> void +RabbitMQ.Client.Exceptions.MalformedFrameException +RabbitMQ.Client.Exceptions.MalformedFrameException.MalformedFrameException(string message) -> void +RabbitMQ.Client.Exceptions.MalformedFrameException.MalformedFrameException(string message, bool canShutdownCleanly) -> void +RabbitMQ.Client.Exceptions.OperationInterruptedException +RabbitMQ.Client.Exceptions.OperationInterruptedException.OperationInterruptedException() -> void +RabbitMQ.Client.Exceptions.OperationInterruptedException.OperationInterruptedException(RabbitMQ.Client.ShutdownEventArgs reason) -> void +RabbitMQ.Client.Exceptions.OperationInterruptedException.OperationInterruptedException(RabbitMQ.Client.ShutdownEventArgs reason, string prefix) -> void +RabbitMQ.Client.Exceptions.OperationInterruptedException.OperationInterruptedException(string message) -> void +RabbitMQ.Client.Exceptions.OperationInterruptedException.OperationInterruptedException(string message, System.Exception inner) -> void +RabbitMQ.Client.Exceptions.OperationInterruptedException.ShutdownReason.get -> RabbitMQ.Client.ShutdownEventArgs +RabbitMQ.Client.Exceptions.OperationInterruptedException.ShutdownReason.set -> void +RabbitMQ.Client.Exceptions.PacketNotRecognizedException +RabbitMQ.Client.Exceptions.PacketNotRecognizedException.PacketNotRecognizedException(int transportHigh, int transportLow, int serverMajor, int serverMinor) -> void +RabbitMQ.Client.Exceptions.PacketNotRecognizedException.ServerMajor.get -> int +RabbitMQ.Client.Exceptions.PacketNotRecognizedException.ServerMinor.get -> int +RabbitMQ.Client.Exceptions.PacketNotRecognizedException.TransportHigh.get -> int +RabbitMQ.Client.Exceptions.PacketNotRecognizedException.TransportLow.get -> int +RabbitMQ.Client.Exceptions.PossibleAuthenticationFailureException +RabbitMQ.Client.Exceptions.PossibleAuthenticationFailureException.PossibleAuthenticationFailureException(string msg) -> void +RabbitMQ.Client.Exceptions.PossibleAuthenticationFailureException.PossibleAuthenticationFailureException(string msg, System.Exception inner) -> void +RabbitMQ.Client.Exceptions.ProtocolException +RabbitMQ.Client.Exceptions.ProtocolException.ProtocolException(string message) -> void +RabbitMQ.Client.Exceptions.ProtocolVersionMismatchException +RabbitMQ.Client.Exceptions.ProtocolVersionMismatchException.ClientMajor.get -> int +RabbitMQ.Client.Exceptions.ProtocolVersionMismatchException.ClientMinor.get -> int +RabbitMQ.Client.Exceptions.ProtocolVersionMismatchException.ProtocolVersionMismatchException(int clientMajor, int clientMinor, int serverMajor, int serverMinor) -> void +RabbitMQ.Client.Exceptions.ProtocolVersionMismatchException.ServerMajor.get -> int +RabbitMQ.Client.Exceptions.ProtocolVersionMismatchException.ServerMinor.get -> int +RabbitMQ.Client.Exceptions.ProtocolViolationException +RabbitMQ.Client.Exceptions.ProtocolViolationException.ProtocolViolationException() -> void +RabbitMQ.Client.Exceptions.ProtocolViolationException.ProtocolViolationException(string message) -> void +RabbitMQ.Client.Exceptions.ProtocolViolationException.ProtocolViolationException(string message, System.Exception inner) -> void +RabbitMQ.Client.Exceptions.RabbitMQClientException +RabbitMQ.Client.Exceptions.RabbitMQClientException.RabbitMQClientException() -> void +RabbitMQ.Client.Exceptions.RabbitMQClientException.RabbitMQClientException(string message) -> void +RabbitMQ.Client.Exceptions.RabbitMQClientException.RabbitMQClientException(string message, System.Exception innerException) -> void +RabbitMQ.Client.Exceptions.SyntaxErrorException +RabbitMQ.Client.Exceptions.SyntaxErrorException.SyntaxErrorException(string message) -> void +RabbitMQ.Client.Exceptions.TopologyRecoveryException +RabbitMQ.Client.Exceptions.TopologyRecoveryException.TopologyRecoveryException(string message, System.Exception cause) -> void +RabbitMQ.Client.Exceptions.UnexpectedFrameException +RabbitMQ.Client.Exceptions.UnexpectedMethodException +RabbitMQ.Client.Exceptions.UnexpectedMethodException.ExpectedProtocolClassId.get -> ushort +RabbitMQ.Client.Exceptions.UnexpectedMethodException.ExpectedProtocolMethodId.get -> ushort +RabbitMQ.Client.Exceptions.UnexpectedMethodException.ExpectedProtocolMethodName.get -> string +RabbitMQ.Client.Exceptions.UnexpectedMethodException.ProtocolClassId.get -> ushort +RabbitMQ.Client.Exceptions.UnexpectedMethodException.ProtocolMethodId.get -> ushort +RabbitMQ.Client.Exceptions.UnexpectedMethodException.ProtocolMethodName.get -> string +RabbitMQ.Client.Exceptions.UnknownClassOrMethodException +RabbitMQ.Client.Exceptions.UnknownClassOrMethodException.ClassId.get -> ushort +RabbitMQ.Client.Exceptions.UnknownClassOrMethodException.MethodId.get -> ushort +RabbitMQ.Client.Exceptions.UnknownClassOrMethodException.UnknownClassOrMethodException(ushort classId, ushort methodId) -> void +RabbitMQ.Client.Exceptions.WireFormattingException +RabbitMQ.Client.Exceptions.WireFormattingException.Offender.get -> object +RabbitMQ.Client.Exceptions.WireFormattingException.WireFormattingException(string message) -> void +RabbitMQ.Client.Exceptions.WireFormattingException.WireFormattingException(string message, object offender) -> void +RabbitMQ.Client.ExchangeType +RabbitMQ.Client.ExternalMechanism +RabbitMQ.Client.ExternalMechanism.ExternalMechanism() -> void +RabbitMQ.Client.ExternalMechanism.handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) -> byte[] +RabbitMQ.Client.ExternalMechanismFactory +RabbitMQ.Client.ExternalMechanismFactory.ExternalMechanismFactory() -> void +RabbitMQ.Client.ExternalMechanismFactory.GetInstance() -> RabbitMQ.Client.IAuthMechanism +RabbitMQ.Client.ExternalMechanismFactory.Name.get -> string +RabbitMQ.Client.Headers +RabbitMQ.Client.IAmqpHeader +RabbitMQ.Client.IAmqpHeader.ProtocolClassId.get -> ushort +RabbitMQ.Client.IAmqpWriteable +RabbitMQ.Client.IAmqpWriteable.GetRequiredBufferSize() -> int +RabbitMQ.Client.IAmqpWriteable.WriteTo(System.Span span) -> int +RabbitMQ.Client.IAsyncBasicConsumer +RabbitMQ.Client.IAsyncBasicConsumer.Channel.get -> RabbitMQ.Client.IChannel +RabbitMQ.Client.IAsyncBasicConsumer.ConsumerCancelled -> RabbitMQ.Client.Events.AsyncEventHandler +RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicCancel(string consumerTag) -> System.Threading.Tasks.Task +RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicCancelOk(string consumerTag) -> System.Threading.Tasks.Task +RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicConsumeOk(string consumerTag) -> System.Threading.Tasks.Task +RabbitMQ.Client.IAsyncBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> System.Threading.Tasks.Task +RabbitMQ.Client.IAsyncBasicConsumer.HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> System.Threading.Tasks.Task +RabbitMQ.Client.IAuthMechanism +RabbitMQ.Client.IAuthMechanism.handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) -> byte[] +RabbitMQ.Client.IAuthMechanismFactory +RabbitMQ.Client.IAuthMechanismFactory.GetInstance() -> RabbitMQ.Client.IAuthMechanism +RabbitMQ.Client.IAuthMechanismFactory.Name.get -> string +RabbitMQ.Client.IBasicConsumer +RabbitMQ.Client.IBasicConsumer.Channel.get -> RabbitMQ.Client.IChannel +RabbitMQ.Client.IBasicConsumer.ConsumerCancelled -> System.EventHandler +RabbitMQ.Client.IBasicConsumer.HandleBasicCancel(string consumerTag) -> void +RabbitMQ.Client.IBasicConsumer.HandleBasicCancelOk(string consumerTag) -> void +RabbitMQ.Client.IBasicConsumer.HandleBasicConsumeOk(string consumerTag) -> void +RabbitMQ.Client.IBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> void +RabbitMQ.Client.IBasicConsumer.HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> void +RabbitMQ.Client.IBasicProperties +RabbitMQ.Client.IBasicProperties.AppId.get -> string +RabbitMQ.Client.IBasicProperties.AppId.set -> void +RabbitMQ.Client.IBasicProperties.ClearAppId() -> void +RabbitMQ.Client.IBasicProperties.ClearClusterId() -> void +RabbitMQ.Client.IBasicProperties.ClearContentEncoding() -> void +RabbitMQ.Client.IBasicProperties.ClearContentType() -> void +RabbitMQ.Client.IBasicProperties.ClearCorrelationId() -> void +RabbitMQ.Client.IBasicProperties.ClearDeliveryMode() -> void +RabbitMQ.Client.IBasicProperties.ClearExpiration() -> void +RabbitMQ.Client.IBasicProperties.ClearHeaders() -> void +RabbitMQ.Client.IBasicProperties.ClearMessageId() -> void +RabbitMQ.Client.IBasicProperties.ClearPriority() -> void +RabbitMQ.Client.IBasicProperties.ClearReplyTo() -> void +RabbitMQ.Client.IBasicProperties.ClearTimestamp() -> void +RabbitMQ.Client.IBasicProperties.ClearType() -> void +RabbitMQ.Client.IBasicProperties.ClearUserId() -> void +RabbitMQ.Client.IBasicProperties.ClusterId.get -> string +RabbitMQ.Client.IBasicProperties.ClusterId.set -> void +RabbitMQ.Client.IBasicProperties.ContentEncoding.get -> string +RabbitMQ.Client.IBasicProperties.ContentEncoding.set -> void +RabbitMQ.Client.IBasicProperties.ContentType.get -> string +RabbitMQ.Client.IBasicProperties.ContentType.set -> void +RabbitMQ.Client.IBasicProperties.CorrelationId.get -> string +RabbitMQ.Client.IBasicProperties.CorrelationId.set -> void +RabbitMQ.Client.IBasicProperties.DeliveryMode.get -> RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.IBasicProperties.DeliveryMode.set -> void +RabbitMQ.Client.IBasicProperties.Expiration.get -> string +RabbitMQ.Client.IBasicProperties.Expiration.set -> void +RabbitMQ.Client.IBasicProperties.Headers.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IBasicProperties.Headers.set -> void +RabbitMQ.Client.IBasicProperties.MessageId.get -> string +RabbitMQ.Client.IBasicProperties.MessageId.set -> void +RabbitMQ.Client.IBasicProperties.Persistent.get -> bool +RabbitMQ.Client.IBasicProperties.Persistent.set -> void +RabbitMQ.Client.IBasicProperties.Priority.get -> byte +RabbitMQ.Client.IBasicProperties.Priority.set -> void +RabbitMQ.Client.IBasicProperties.ReplyTo.get -> string +RabbitMQ.Client.IBasicProperties.ReplyTo.set -> void +RabbitMQ.Client.IBasicProperties.ReplyToAddress.get -> RabbitMQ.Client.PublicationAddress +RabbitMQ.Client.IBasicProperties.ReplyToAddress.set -> void +RabbitMQ.Client.IBasicProperties.Timestamp.get -> RabbitMQ.Client.AmqpTimestamp +RabbitMQ.Client.IBasicProperties.Timestamp.set -> void +RabbitMQ.Client.IBasicProperties.Type.get -> string +RabbitMQ.Client.IBasicProperties.Type.set -> void +RabbitMQ.Client.IBasicProperties.UserId.get -> string +RabbitMQ.Client.IBasicProperties.UserId.set -> void +RabbitMQ.Client.IChannel +RabbitMQ.Client.IChannel.BasicAck(ulong deliveryTag, bool multiple) -> void +RabbitMQ.Client.IChannel.BasicAckAsync(ulong deliveryTag, bool multiple) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicAcks -> System.EventHandler +RabbitMQ.Client.IChannel.BasicCancel(string consumerTag) -> void +RabbitMQ.Client.IChannel.BasicCancelAsync(string consumerTag) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicCancelNoWait(string consumerTag) -> void +RabbitMQ.Client.IChannel.BasicConsume(string queue, bool autoAck, string consumerTag, bool noLocal, bool exclusive, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer) -> string +RabbitMQ.Client.IChannel.BasicConsumeAsync(string queue, bool autoAck, string consumerTag, bool noLocal, bool exclusive, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicGet(string queue, bool autoAck) -> RabbitMQ.Client.BasicGetResult +RabbitMQ.Client.IChannel.BasicGetAsync(string queue, bool autoAck) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicNack(ulong deliveryTag, bool multiple, bool requeue) -> void +RabbitMQ.Client.IChannel.BasicNackAsync(ulong deliveryTag, bool multiple, bool requeue) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicNacks -> System.EventHandler +RabbitMQ.Client.IChannel.BasicPublish(RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> void +RabbitMQ.Client.IChannel.BasicPublish(string exchange, string routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> void +RabbitMQ.Client.IChannel.BasicPublishAsync(RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicPublishAsync(string exchange, string routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicQos(uint prefetchSize, ushort prefetchCount, bool global) -> void +RabbitMQ.Client.IChannel.BasicQosAsync(uint prefetchSize, ushort prefetchCount, bool global) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicReject(ulong deliveryTag, bool requeue) -> void +RabbitMQ.Client.IChannel.BasicRejectAsync(ulong deliveryTag, bool requeue) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.BasicReturn -> System.EventHandler +RabbitMQ.Client.IChannel.CallbackException -> System.EventHandler +RabbitMQ.Client.IChannel.ChannelNumber.get -> int +RabbitMQ.Client.IChannel.ChannelShutdown -> System.EventHandler +RabbitMQ.Client.IChannel.Close(ushort replyCode, string replyText, bool abort) -> void +RabbitMQ.Client.IChannel.CloseAsync(RabbitMQ.Client.ShutdownEventArgs reason, bool abort) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.CloseAsync(ushort replyCode, string replyText, bool abort) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.CloseReason.get -> RabbitMQ.Client.ShutdownEventArgs +RabbitMQ.Client.IChannel.ConfirmSelect() -> void +RabbitMQ.Client.IChannel.ConfirmSelectAsync() -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.ConsumerCount(string queue) -> uint +RabbitMQ.Client.IChannel.ContinuationTimeout.get -> System.TimeSpan +RabbitMQ.Client.IChannel.ContinuationTimeout.set -> void +RabbitMQ.Client.IChannel.CurrentQueue.get -> string +RabbitMQ.Client.IChannel.DefaultConsumer.get -> RabbitMQ.Client.IBasicConsumer +RabbitMQ.Client.IChannel.DefaultConsumer.set -> void +RabbitMQ.Client.IChannel.ExchangeBind(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.ExchangeBindAsync(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.ExchangeBindNoWait(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.ExchangeDeclare(string exchange, string type, bool durable, bool autoDelete, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.ExchangeDeclareAsync(string exchange, string type, bool passive, bool durable, bool autoDelete, System.Collections.Generic.IDictionary arguments) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.ExchangeDeclareNoWait(string exchange, string type, bool durable, bool autoDelete, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.ExchangeDeclarePassive(string exchange) -> void +RabbitMQ.Client.IChannel.ExchangeDelete(string exchange, bool ifUnused) -> void +RabbitMQ.Client.IChannel.ExchangeDeleteAsync(string exchange, bool ifUnused) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.ExchangeDeleteNoWait(string exchange, bool ifUnused) -> void +RabbitMQ.Client.IChannel.ExchangeUnbind(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.ExchangeUnbindAsync(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.ExchangeUnbindNoWait(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.FlowControl -> System.EventHandler +RabbitMQ.Client.IChannel.IsClosed.get -> bool +RabbitMQ.Client.IChannel.IsOpen.get -> bool +RabbitMQ.Client.IChannel.MessageCount(string queue) -> uint +RabbitMQ.Client.IChannel.NextPublishSeqNo.get -> ulong +RabbitMQ.Client.IChannel.QueueBind(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.QueueBindAsync(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.QueueBindNoWait(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.QueueDeclare(string queue, bool durable, bool exclusive, bool autoDelete, System.Collections.Generic.IDictionary arguments) -> RabbitMQ.Client.QueueDeclareOk +RabbitMQ.Client.IChannel.QueueDeclareAsync(string queue, bool passive, bool durable, bool exclusive, bool autoDelete, System.Collections.Generic.IDictionary arguments) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.QueueDeclareNoWait(string queue, bool durable, bool exclusive, bool autoDelete, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.QueueDeclarePassive(string queue) -> RabbitMQ.Client.QueueDeclareOk +RabbitMQ.Client.IChannel.QueueDelete(string queue, bool ifUnused, bool ifEmpty) -> uint +RabbitMQ.Client.IChannel.QueueDeleteAsync(string queue, bool ifUnused, bool ifEmpty) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.QueueDeleteNoWait(string queue, bool ifUnused, bool ifEmpty) -> void +RabbitMQ.Client.IChannel.QueuePurge(string queue) -> uint +RabbitMQ.Client.IChannel.QueuePurgeAsync(string queue) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.QueueUnbind(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments) -> void +RabbitMQ.Client.IChannel.QueueUnbindAsync(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.TxCommit() -> void +RabbitMQ.Client.IChannel.TxCommitAsync() -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.TxRollback() -> void +RabbitMQ.Client.IChannel.TxRollbackAsync() -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.TxSelect() -> void +RabbitMQ.Client.IChannel.TxSelectAsync() -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IChannel.WaitForConfirmsAsync(System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task +RabbitMQ.Client.IChannel.WaitForConfirmsOrDieAsync(System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task +RabbitMQ.Client.IChannelExtensions +RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnection.CallbackException -> System.EventHandler +RabbitMQ.Client.IConnection.ChannelMax.get -> ushort +RabbitMQ.Client.IConnection.ClientProperties.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IConnection.ClientProvidedName.get -> string +RabbitMQ.Client.IConnection.Close(ushort reasonCode, string reasonText, System.TimeSpan timeout, bool abort) -> void +RabbitMQ.Client.IConnection.CloseAsync(ushort reasonCode, string reasonText, System.TimeSpan timeout, bool abort) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnection.CloseReason.get -> RabbitMQ.Client.ShutdownEventArgs +RabbitMQ.Client.IConnection.ConnectionBlocked -> System.EventHandler +RabbitMQ.Client.IConnection.ConnectionRecoveryError -> System.EventHandler +RabbitMQ.Client.IConnection.ConnectionShutdown -> System.EventHandler +RabbitMQ.Client.IConnection.ConnectionUnblocked -> System.EventHandler +RabbitMQ.Client.IConnection.ConsumerTagChangeAfterRecovery -> System.EventHandler +RabbitMQ.Client.IConnection.CreateChannel() -> RabbitMQ.Client.IChannel +RabbitMQ.Client.IConnection.CreateChannelAsync() -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnection.Endpoint.get -> RabbitMQ.Client.AmqpTcpEndpoint +RabbitMQ.Client.IConnection.FrameMax.get -> uint +RabbitMQ.Client.IConnection.Heartbeat.get -> System.TimeSpan +RabbitMQ.Client.IConnection.IsOpen.get -> bool +RabbitMQ.Client.IConnection.Protocol.get -> RabbitMQ.Client.IProtocol +RabbitMQ.Client.IConnection.QueueNameChangedAfterRecovery -> System.EventHandler +RabbitMQ.Client.IConnection.RecoveringConsumer -> System.EventHandler +RabbitMQ.Client.IConnection.RecoverySucceeded -> System.EventHandler +RabbitMQ.Client.IConnection.ServerProperties.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IConnection.ShutdownReport.get -> System.Collections.Generic.IEnumerable +RabbitMQ.Client.IConnection.UpdateSecret(string newSecret, string reason) -> void +RabbitMQ.Client.IConnectionExtensions +RabbitMQ.Client.IConnectionFactory +RabbitMQ.Client.IConnectionFactory.AuthMechanismFactory(System.Collections.Generic.IEnumerable mechanismNames) -> RabbitMQ.Client.IAuthMechanismFactory +RabbitMQ.Client.IConnectionFactory.ClientProperties.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IConnectionFactory.ClientProperties.set -> void +RabbitMQ.Client.IConnectionFactory.ClientProvidedName.get -> string +RabbitMQ.Client.IConnectionFactory.ClientProvidedName.set -> void +RabbitMQ.Client.IConnectionFactory.ConsumerDispatchConcurrency.get -> int +RabbitMQ.Client.IConnectionFactory.ConsumerDispatchConcurrency.set -> void +RabbitMQ.Client.IConnectionFactory.ContinuationTimeout.get -> System.TimeSpan +RabbitMQ.Client.IConnectionFactory.ContinuationTimeout.set -> void +RabbitMQ.Client.IConnectionFactory.CreateConnection() -> RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnectionFactory.CreateConnection(string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable endpoints) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable hostnames) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnectionFactory.CreateConnection(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName) -> RabbitMQ.Client.IConnection +RabbitMQ.Client.IConnectionFactory.CreateConnectionAsync(string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnectionFactory.CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnectionFactory.CreateConnectionAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +RabbitMQ.Client.IConnectionFactory.CredentialsProvider.get -> RabbitMQ.Client.ICredentialsProvider +RabbitMQ.Client.IConnectionFactory.CredentialsProvider.set -> void +RabbitMQ.Client.IConnectionFactory.CredentialsRefresher.get -> RabbitMQ.Client.ICredentialsRefresher +RabbitMQ.Client.IConnectionFactory.CredentialsRefresher.set -> void +RabbitMQ.Client.IConnectionFactory.DispatchConsumersAsync.get -> bool +RabbitMQ.Client.IConnectionFactory.DispatchConsumersAsync.set -> void +RabbitMQ.Client.IConnectionFactory.HandshakeContinuationTimeout.get -> System.TimeSpan +RabbitMQ.Client.IConnectionFactory.HandshakeContinuationTimeout.set -> void +RabbitMQ.Client.IConnectionFactory.Password.get -> string +RabbitMQ.Client.IConnectionFactory.Password.set -> void +RabbitMQ.Client.IConnectionFactory.RequestedChannelMax.get -> ushort +RabbitMQ.Client.IConnectionFactory.RequestedChannelMax.set -> void +RabbitMQ.Client.IConnectionFactory.RequestedFrameMax.get -> uint +RabbitMQ.Client.IConnectionFactory.RequestedFrameMax.set -> void +RabbitMQ.Client.IConnectionFactory.RequestedHeartbeat.get -> System.TimeSpan +RabbitMQ.Client.IConnectionFactory.RequestedHeartbeat.set -> void +RabbitMQ.Client.IConnectionFactory.Uri.get -> System.Uri +RabbitMQ.Client.IConnectionFactory.Uri.set -> void +RabbitMQ.Client.IConnectionFactory.UserName.get -> string +RabbitMQ.Client.IConnectionFactory.UserName.set -> void +RabbitMQ.Client.IConnectionFactory.VirtualHost.get -> string +RabbitMQ.Client.IConnectionFactory.VirtualHost.set -> void +RabbitMQ.Client.ICredentialsProvider +RabbitMQ.Client.ICredentialsProvider.Name.get -> string +RabbitMQ.Client.ICredentialsProvider.Password.get -> string +RabbitMQ.Client.ICredentialsProvider.Refresh() -> void +RabbitMQ.Client.ICredentialsProvider.UserName.get -> string +RabbitMQ.Client.ICredentialsProvider.ValidUntil.get -> System.TimeSpan? +RabbitMQ.Client.ICredentialsRefresher +RabbitMQ.Client.ICredentialsRefresher.NotifyCredentialRefreshed +RabbitMQ.Client.ICredentialsRefresher.Register(RabbitMQ.Client.ICredentialsProvider provider, RabbitMQ.Client.ICredentialsRefresher.NotifyCredentialRefreshed callback) -> RabbitMQ.Client.ICredentialsProvider +RabbitMQ.Client.ICredentialsRefresher.Unregister(RabbitMQ.Client.ICredentialsProvider provider) -> bool +RabbitMQ.Client.IEndpointResolver +RabbitMQ.Client.IEndpointResolver.All() -> System.Collections.Generic.IEnumerable +RabbitMQ.Client.INetworkConnection +RabbitMQ.Client.INetworkConnection.LocalPort.get -> int +RabbitMQ.Client.INetworkConnection.RemotePort.get -> int +RabbitMQ.Client.IProtocol +RabbitMQ.Client.IProtocol.ApiName.get -> string +RabbitMQ.Client.IProtocol.DefaultPort.get -> int +RabbitMQ.Client.IProtocol.MajorVersion.get -> int +RabbitMQ.Client.IProtocol.MinorVersion.get -> int +RabbitMQ.Client.IProtocol.Revision.get -> int +RabbitMQ.Client.IReadOnlyBasicProperties +RabbitMQ.Client.IReadOnlyBasicProperties.AppId.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.ClusterId.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.ContentEncoding.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.ContentType.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.CorrelationId.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.DeliveryMode.get -> RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.IReadOnlyBasicProperties.Expiration.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.Headers.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IReadOnlyBasicProperties.IsAppIdPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsClusterIdPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsContentEncodingPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsContentTypePresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsCorrelationIdPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsDeliveryModePresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsExpirationPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsHeadersPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsMessageIdPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsPriorityPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsReplyToPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsTimestampPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsTypePresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.IsUserIdPresent() -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.MessageId.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.Persistent.get -> bool +RabbitMQ.Client.IReadOnlyBasicProperties.Priority.get -> byte +RabbitMQ.Client.IReadOnlyBasicProperties.ReplyTo.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.ReplyToAddress.get -> RabbitMQ.Client.PublicationAddress +RabbitMQ.Client.IReadOnlyBasicProperties.Timestamp.get -> RabbitMQ.Client.AmqpTimestamp +RabbitMQ.Client.IReadOnlyBasicProperties.Type.get -> string +RabbitMQ.Client.IReadOnlyBasicProperties.UserId.get -> string +RabbitMQ.Client.IRecordedBinding +RabbitMQ.Client.IRecordedBinding.Arguments.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IRecordedBinding.Destination.get -> string +RabbitMQ.Client.IRecordedBinding.RoutingKey.get -> string +RabbitMQ.Client.IRecordedBinding.Source.get -> string +RabbitMQ.Client.IRecordedConsumer +RabbitMQ.Client.IRecordedConsumer.Arguments.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IRecordedConsumer.AutoAck.get -> bool +RabbitMQ.Client.IRecordedConsumer.ConsumerTag.get -> string +RabbitMQ.Client.IRecordedConsumer.Exclusive.get -> bool +RabbitMQ.Client.IRecordedConsumer.Queue.get -> string +RabbitMQ.Client.IRecordedExchange +RabbitMQ.Client.IRecordedExchange.Arguments.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IRecordedExchange.AutoDelete.get -> bool +RabbitMQ.Client.IRecordedExchange.Durable.get -> bool +RabbitMQ.Client.IRecordedExchange.Name.get -> string +RabbitMQ.Client.IRecordedExchange.Type.get -> string +RabbitMQ.Client.IRecordedQueue +RabbitMQ.Client.IRecordedQueue.Arguments.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.IRecordedQueue.AutoDelete.get -> bool +RabbitMQ.Client.IRecordedQueue.Durable.get -> bool +RabbitMQ.Client.IRecordedQueue.Exclusive.get -> bool +RabbitMQ.Client.IRecordedQueue.IsServerNamed.get -> bool +RabbitMQ.Client.IRecordedQueue.Name.get -> string +RabbitMQ.Client.IRecoverable +RabbitMQ.Client.IRecoverable.Recovery -> System.EventHandler +RabbitMQ.Client.ITcpClient +RabbitMQ.Client.ITcpClient.Client.get -> System.Net.Sockets.Socket +RabbitMQ.Client.ITcpClient.Close() -> void +RabbitMQ.Client.ITcpClient.ConnectAsync(System.Net.IPAddress host, int port, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task +RabbitMQ.Client.ITcpClient.Connected.get -> bool +RabbitMQ.Client.ITcpClient.GetStream() -> System.Net.Sockets.NetworkStream +RabbitMQ.Client.ITcpClient.ReceiveTimeout.get -> System.TimeSpan +RabbitMQ.Client.ITcpClient.ReceiveTimeout.set -> void +RabbitMQ.Client.Logging.RabbitMqExceptionDetail +RabbitMQ.Client.Logging.RabbitMqExceptionDetail.InnerException.get -> string +RabbitMQ.Client.Logging.RabbitMqExceptionDetail.Message.get -> string +RabbitMQ.Client.Logging.RabbitMqExceptionDetail.RabbitMqExceptionDetail(System.Collections.Generic.IDictionary ex) -> void +RabbitMQ.Client.Logging.RabbitMqExceptionDetail.RabbitMqExceptionDetail(System.Exception ex) -> void +RabbitMQ.Client.Logging.RabbitMqExceptionDetail.StackTrace.get -> string +RabbitMQ.Client.Logging.RabbitMqExceptionDetail.Type.get -> string +RabbitMQ.Client.PlainMechanism +RabbitMQ.Client.PlainMechanism.handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) -> byte[] +RabbitMQ.Client.PlainMechanism.PlainMechanism() -> void +RabbitMQ.Client.PlainMechanismFactory +RabbitMQ.Client.PlainMechanismFactory.GetInstance() -> RabbitMQ.Client.IAuthMechanism +RabbitMQ.Client.PlainMechanismFactory.Name.get -> string +RabbitMQ.Client.PlainMechanismFactory.PlainMechanismFactory() -> void +RabbitMQ.Client.Protocols +RabbitMQ.Client.PublicationAddress +RabbitMQ.Client.PublicationAddress.PublicationAddress(string exchangeType, string exchangeName, string routingKey) -> void +RabbitMQ.Client.QueueDeclareOk +RabbitMQ.Client.QueueDeclareOk.QueueDeclareOk(string queueName, uint messageCount, uint consumerCount) -> void +RabbitMQ.Client.ReadOnlyBasicProperties +RabbitMQ.Client.ReadOnlyBasicProperties.AppId.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.ClusterId.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.ContentEncoding.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.ContentType.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.CorrelationId.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.DeliveryMode.get -> RabbitMQ.Client.DeliveryModes +RabbitMQ.Client.ReadOnlyBasicProperties.Expiration.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.Headers.get -> System.Collections.Generic.IDictionary +RabbitMQ.Client.ReadOnlyBasicProperties.IsAppIdPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsClusterIdPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsContentEncodingPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsContentTypePresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsCorrelationIdPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsDeliveryModePresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsExpirationPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsHeadersPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsMessageIdPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsPriorityPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsReplyToPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsTimestampPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsTypePresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.IsUserIdPresent() -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.MessageId.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.Persistent.get -> bool +RabbitMQ.Client.ReadOnlyBasicProperties.Priority.get -> byte +RabbitMQ.Client.ReadOnlyBasicProperties.ReadOnlyBasicProperties() -> void +RabbitMQ.Client.ReadOnlyBasicProperties.ReadOnlyBasicProperties(System.ReadOnlySpan span) -> void +RabbitMQ.Client.ReadOnlyBasicProperties.ReplyTo.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.ReplyToAddress.get -> RabbitMQ.Client.PublicationAddress +RabbitMQ.Client.ReadOnlyBasicProperties.Timestamp.get -> RabbitMQ.Client.AmqpTimestamp +RabbitMQ.Client.ReadOnlyBasicProperties.Type.get -> string +RabbitMQ.Client.ReadOnlyBasicProperties.UserId.get -> string +RabbitMQ.Client.ShutdownEventArgs +RabbitMQ.Client.ShutdownEventArgs.Cause.get -> object +RabbitMQ.Client.ShutdownEventArgs.ClassId.get -> ushort +RabbitMQ.Client.ShutdownEventArgs.Exception.get -> System.Exception +RabbitMQ.Client.ShutdownEventArgs.Initiator.get -> RabbitMQ.Client.ShutdownInitiator +RabbitMQ.Client.ShutdownEventArgs.MethodId.get -> ushort +RabbitMQ.Client.ShutdownEventArgs.ReplyCode.get -> ushort +RabbitMQ.Client.ShutdownEventArgs.ReplyText.get -> string +RabbitMQ.Client.ShutdownEventArgs.ShutdownEventArgs(RabbitMQ.Client.ShutdownInitiator initiator, ushort replyCode, string replyText, object cause = null) -> void +RabbitMQ.Client.ShutdownEventArgs.ShutdownEventArgs(RabbitMQ.Client.ShutdownInitiator initiator, ushort replyCode, string replyText, System.Exception exception) -> void +RabbitMQ.Client.ShutdownEventArgs.ShutdownEventArgs(RabbitMQ.Client.ShutdownInitiator initiator, ushort replyCode, string replyText, ushort classId, ushort methodId, object cause = null) -> void +RabbitMQ.Client.ShutdownInitiator +RabbitMQ.Client.ShutdownInitiator.Application = 0 -> RabbitMQ.Client.ShutdownInitiator +RabbitMQ.Client.ShutdownInitiator.Library = 1 -> RabbitMQ.Client.ShutdownInitiator +RabbitMQ.Client.ShutdownInitiator.Peer = 2 -> RabbitMQ.Client.ShutdownInitiator +RabbitMQ.Client.ShutdownReportEntry +RabbitMQ.Client.ShutdownReportEntry.Description.get -> string +RabbitMQ.Client.ShutdownReportEntry.Description.set -> void +RabbitMQ.Client.ShutdownReportEntry.Exception.get -> System.Exception +RabbitMQ.Client.ShutdownReportEntry.Exception.set -> void +RabbitMQ.Client.ShutdownReportEntry.ShutdownReportEntry(string description, System.Exception exception) -> void +RabbitMQ.Client.SslOption +RabbitMQ.Client.SslOption.AcceptablePolicyErrors.get -> System.Net.Security.SslPolicyErrors +RabbitMQ.Client.SslOption.AcceptablePolicyErrors.set -> void +RabbitMQ.Client.SslOption.CertificateSelectionCallback.get -> System.Net.Security.LocalCertificateSelectionCallback +RabbitMQ.Client.SslOption.CertificateSelectionCallback.set -> void +RabbitMQ.Client.SslOption.CertificateValidationCallback.get -> System.Net.Security.RemoteCertificateValidationCallback +RabbitMQ.Client.SslOption.CertificateValidationCallback.set -> void +RabbitMQ.Client.SslOption.CertPassphrase.get -> string +RabbitMQ.Client.SslOption.CertPassphrase.set -> void +RabbitMQ.Client.SslOption.CertPath.get -> string +RabbitMQ.Client.SslOption.CertPath.set -> void +RabbitMQ.Client.SslOption.Certs.get -> System.Security.Cryptography.X509Certificates.X509CertificateCollection +RabbitMQ.Client.SslOption.Certs.set -> void +RabbitMQ.Client.SslOption.CheckCertificateRevocation.get -> bool +RabbitMQ.Client.SslOption.CheckCertificateRevocation.set -> void +RabbitMQ.Client.SslOption.Enabled.get -> bool +RabbitMQ.Client.SslOption.Enabled.set -> void +RabbitMQ.Client.SslOption.ServerName.get -> string +RabbitMQ.Client.SslOption.ServerName.set -> void +RabbitMQ.Client.SslOption.SslOption() -> void +RabbitMQ.Client.SslOption.SslOption(string serverName, string certificatePath = "", bool enabled = false) -> void +RabbitMQ.Client.SslOption.Version.get -> System.Security.Authentication.SslProtocols +RabbitMQ.Client.SslOption.Version.set -> void +RabbitMQ.Client.TcpClientAdapter +RabbitMQ.Client.TcpClientAdapter.Dispose() -> void +RabbitMQ.Client.TcpClientAdapter.TcpClientAdapter(System.Net.Sockets.Socket socket) -> void +RabbitMQ.Client.TimerBasedCredentialRefresher +RabbitMQ.Client.TimerBasedCredentialRefresher.Register(RabbitMQ.Client.ICredentialsProvider provider, RabbitMQ.Client.ICredentialsRefresher.NotifyCredentialRefreshed callback) -> RabbitMQ.Client.ICredentialsProvider +RabbitMQ.Client.TimerBasedCredentialRefresher.TimerBasedCredentialRefresher() -> void +RabbitMQ.Client.TimerBasedCredentialRefresher.Unregister(RabbitMQ.Client.ICredentialsProvider provider) -> bool +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.AlreadyRegistered(string name) -> void +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.RefreshedCredentials(string name, bool succesfully) -> void +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.Registered(string name) -> void +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.ScheduledTimer(string name, double interval) -> void +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.TimerBasedCredentialRefresherEventSource() -> void +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.TriggeredTimer(string name) -> void +RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.Unregistered(string name) -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler +RabbitMQ.Client.TopologyRecoveryExceptionHandler.BindingRecoveryExceptionCondition.get -> System.Func +RabbitMQ.Client.TopologyRecoveryExceptionHandler.BindingRecoveryExceptionCondition.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.BindingRecoveryExceptionHandler.get -> System.Action +RabbitMQ.Client.TopologyRecoveryExceptionHandler.BindingRecoveryExceptionHandler.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ConsumerRecoveryExceptionCondition.get -> System.Func +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ConsumerRecoveryExceptionCondition.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ConsumerRecoveryExceptionHandler.get -> System.Action +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ConsumerRecoveryExceptionHandler.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ExchangeRecoveryExceptionCondition.get -> System.Func +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ExchangeRecoveryExceptionCondition.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ExchangeRecoveryExceptionHandler.get -> System.Action +RabbitMQ.Client.TopologyRecoveryExceptionHandler.ExchangeRecoveryExceptionHandler.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.QueueRecoveryExceptionCondition.get -> System.Func +RabbitMQ.Client.TopologyRecoveryExceptionHandler.QueueRecoveryExceptionCondition.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.QueueRecoveryExceptionHandler.get -> System.Action +RabbitMQ.Client.TopologyRecoveryExceptionHandler.QueueRecoveryExceptionHandler.set -> void +RabbitMQ.Client.TopologyRecoveryExceptionHandler.TopologyRecoveryExceptionHandler() -> void +RabbitMQ.Client.TopologyRecoveryFilter +RabbitMQ.Client.TopologyRecoveryFilter.BindingFilter.get -> System.Func +RabbitMQ.Client.TopologyRecoveryFilter.BindingFilter.set -> void +RabbitMQ.Client.TopologyRecoveryFilter.ConsumerFilter.get -> System.Func +RabbitMQ.Client.TopologyRecoveryFilter.ConsumerFilter.set -> void +RabbitMQ.Client.TopologyRecoveryFilter.ExchangeFilter.get -> System.Func +RabbitMQ.Client.TopologyRecoveryFilter.ExchangeFilter.set -> void +RabbitMQ.Client.TopologyRecoveryFilter.QueueFilter.get -> System.Func +RabbitMQ.Client.TopologyRecoveryFilter.QueueFilter.set -> void +RabbitMQ.Client.TopologyRecoveryFilter.TopologyRecoveryFilter() -> void +readonly RabbitMQ.Client.AmqpTimestamp.UnixTime -> long +readonly RabbitMQ.Client.BasicGetResult.BasicProperties -> RabbitMQ.Client.ReadOnlyBasicProperties +readonly RabbitMQ.Client.BasicGetResult.Body -> System.ReadOnlyMemory +readonly RabbitMQ.Client.BasicGetResult.DeliveryTag -> ulong +readonly RabbitMQ.Client.BasicGetResult.Exchange -> string +readonly RabbitMQ.Client.BasicGetResult.MessageCount -> uint +readonly RabbitMQ.Client.BasicGetResult.Redelivered -> bool +readonly RabbitMQ.Client.BasicGetResult.RoutingKey -> string +readonly RabbitMQ.Client.CachedString.Bytes -> System.ReadOnlyMemory +readonly RabbitMQ.Client.CachedString.Value -> string +readonly RabbitMQ.Client.ConnectionConfig.AuthMechanisms -> System.Collections.Generic.IEnumerable +readonly RabbitMQ.Client.ConnectionConfig.ClientProperties -> System.Collections.Generic.IDictionary +readonly RabbitMQ.Client.ConnectionConfig.ClientProvidedName -> string +readonly RabbitMQ.Client.ConnectionConfig.ContinuationTimeout -> System.TimeSpan +readonly RabbitMQ.Client.ConnectionConfig.DispatchConsumerConcurrency -> int +readonly RabbitMQ.Client.ConnectionConfig.DispatchConsumersAsync -> bool +readonly RabbitMQ.Client.ConnectionConfig.HandshakeContinuationTimeout -> System.TimeSpan +readonly RabbitMQ.Client.ConnectionConfig.HeartbeatInterval -> System.TimeSpan +readonly RabbitMQ.Client.ConnectionConfig.MaxChannelCount -> ushort +readonly RabbitMQ.Client.ConnectionConfig.MaxFrameSize -> uint +readonly RabbitMQ.Client.ConnectionConfig.NetworkRecoveryInterval -> System.TimeSpan +readonly RabbitMQ.Client.ConnectionConfig.Password -> string +readonly RabbitMQ.Client.ConnectionConfig.RequestedConnectionTimeout -> System.TimeSpan +readonly RabbitMQ.Client.ConnectionConfig.TopologyRecoveryEnabled -> bool +readonly RabbitMQ.Client.ConnectionConfig.TopologyRecoveryExceptionHandler -> RabbitMQ.Client.TopologyRecoveryExceptionHandler +readonly RabbitMQ.Client.ConnectionConfig.TopologyRecoveryFilter -> RabbitMQ.Client.TopologyRecoveryFilter +readonly RabbitMQ.Client.ConnectionConfig.UserName -> string +readonly RabbitMQ.Client.ConnectionConfig.VirtualHost -> string +readonly RabbitMQ.Client.Events.BaseExceptionEventArgs.Detail -> System.Collections.Generic.IDictionary +readonly RabbitMQ.Client.Events.BaseExceptionEventArgs.Exception -> System.Exception +readonly RabbitMQ.Client.Events.BasicAckEventArgs.DeliveryTag -> ulong +readonly RabbitMQ.Client.Events.BasicAckEventArgs.Multiple -> bool +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.BasicProperties -> RabbitMQ.Client.ReadOnlyBasicProperties +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.Body -> System.ReadOnlyMemory +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.ConsumerTag -> string +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.DeliveryTag -> ulong +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.Exchange -> string +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.Redelivered -> bool +readonly RabbitMQ.Client.Events.BasicDeliverEventArgs.RoutingKey -> string +readonly RabbitMQ.Client.Events.BasicNackEventArgs.DeliveryTag -> ulong +readonly RabbitMQ.Client.Events.BasicNackEventArgs.Multiple -> bool +readonly RabbitMQ.Client.Events.BasicNackEventArgs.Requeue -> bool +readonly RabbitMQ.Client.Events.BasicReturnEventArgs.BasicProperties -> RabbitMQ.Client.ReadOnlyBasicProperties +readonly RabbitMQ.Client.Events.BasicReturnEventArgs.Body -> System.ReadOnlyMemory +readonly RabbitMQ.Client.Events.BasicReturnEventArgs.Exchange -> string +readonly RabbitMQ.Client.Events.BasicReturnEventArgs.ReplyCode -> ushort +readonly RabbitMQ.Client.Events.BasicReturnEventArgs.ReplyText -> string +readonly RabbitMQ.Client.Events.BasicReturnEventArgs.RoutingKey -> string +readonly RabbitMQ.Client.Events.ConnectionBlockedEventArgs.Reason -> string +readonly RabbitMQ.Client.Events.ConnectionRecoveryErrorEventArgs.Exception -> System.Exception +readonly RabbitMQ.Client.Events.ConsumerEventArgs.ConsumerTags -> string[] +readonly RabbitMQ.Client.Events.ConsumerTagChangedAfterRecoveryEventArgs.TagAfter -> string +readonly RabbitMQ.Client.Events.ConsumerTagChangedAfterRecoveryEventArgs.TagBefore -> string +readonly RabbitMQ.Client.Events.FlowControlEventArgs.Active -> bool +readonly RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.NameAfter -> string +readonly RabbitMQ.Client.Events.QueueNameChangedAfterRecoveryEventArgs.NameBefore -> string +readonly RabbitMQ.Client.Exceptions.HardProtocolException._canShutdownCleanly -> bool +readonly RabbitMQ.Client.PublicationAddress.ExchangeName -> string +readonly RabbitMQ.Client.PublicationAddress.ExchangeType -> string +readonly RabbitMQ.Client.PublicationAddress.RoutingKey -> string +readonly RabbitMQ.Client.QueueDeclareOk.ConsumerCount -> uint +readonly RabbitMQ.Client.QueueDeclareOk.MessageCount -> uint +readonly RabbitMQ.Client.QueueDeclareOk.QueueName -> string +static RabbitMQ.Client.AmqpTcpEndpoint.Parse(string address) -> RabbitMQ.Client.AmqpTcpEndpoint +static RabbitMQ.Client.AmqpTcpEndpoint.ParseMultiple(string addresses) -> RabbitMQ.Client.AmqpTcpEndpoint[] +static RabbitMQ.Client.AmqpTimestamp.operator !=(RabbitMQ.Client.AmqpTimestamp left, RabbitMQ.Client.AmqpTimestamp right) -> bool +static RabbitMQ.Client.AmqpTimestamp.operator ==(RabbitMQ.Client.AmqpTimestamp left, RabbitMQ.Client.AmqpTimestamp right) -> bool +static RabbitMQ.Client.ConnectionFactory.DefaultAddressFamily.get -> System.Net.Sockets.AddressFamily +static RabbitMQ.Client.ConnectionFactory.DefaultAddressFamily.set -> void +static RabbitMQ.Client.ConnectionFactory.DefaultAmqpUriSslProtocols.get -> System.Security.Authentication.SslProtocols +static RabbitMQ.Client.ConnectionFactory.DefaultAmqpUriSslProtocols.set -> void +static RabbitMQ.Client.ConnectionFactoryBase.DefaultSocketFactory(System.Net.Sockets.AddressFamily addressFamily) -> RabbitMQ.Client.ITcpClient +static RabbitMQ.Client.EndpointResolverExtensions.SelectOneAsync(this RabbitMQ.Client.IEndpointResolver resolver, System.Func> selector, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task +static RabbitMQ.Client.Events.CallbackExceptionEventArgs.Build(System.Exception e, string context) -> RabbitMQ.Client.Events.CallbackExceptionEventArgs +static RabbitMQ.Client.Events.CallbackExceptionEventArgs.Build(System.Exception e, string context, object consumer) -> RabbitMQ.Client.Events.CallbackExceptionEventArgs +static RabbitMQ.Client.ExchangeType.All() -> System.Collections.Generic.ICollection +static RabbitMQ.Client.IChannelExtensions.Abort(this RabbitMQ.Client.IChannel channel) -> void +static RabbitMQ.Client.IChannelExtensions.Abort(this RabbitMQ.Client.IChannel channel, ushort replyCode, string replyText) -> void +static RabbitMQ.Client.IChannelExtensions.AbortAsync(this RabbitMQ.Client.IChannel channel) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicConsume(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.IBasicConsumer consumer, string queue, bool autoAck = false, string consumerTag = "", bool noLocal = false, bool exclusive = false, System.Collections.Generic.IDictionary arguments = null) -> string +static RabbitMQ.Client.IChannelExtensions.BasicConsume(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, RabbitMQ.Client.IBasicConsumer consumer) -> string +static RabbitMQ.Client.IChannelExtensions.BasicConsume(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, RabbitMQ.Client.IBasicConsumer consumer) -> string +static RabbitMQ.Client.IChannelExtensions.BasicConsume(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer) -> string +static RabbitMQ.Client.IChannelExtensions.BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.IBasicConsumer consumer, string queue, bool autoAck = false, string consumerTag = "", bool noLocal = false, bool exclusive = false, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, RabbitMQ.Client.IBasicConsumer consumer) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, RabbitMQ.Client.IBasicConsumer consumer) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicPublish(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> void +static RabbitMQ.Client.IChannelExtensions.BasicPublish(this RabbitMQ.Client.IChannel channel, string exchange, string routingKey, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> void +static RabbitMQ.Client.IChannelExtensions.BasicPublish(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.PublicationAddress addr, in T basicProperties, System.ReadOnlyMemory body) -> void +static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client.IChannel channel, string exchange, string routingKey, System.ReadOnlyMemory body = default(System.ReadOnlyMemory), bool mandatory = false) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.BasicPublishAsync(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.PublicationAddress addr, in T basicProperties, System.ReadOnlyMemory body) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.Close(this RabbitMQ.Client.IChannel channel) -> void +static RabbitMQ.Client.IChannelExtensions.Close(this RabbitMQ.Client.IChannel channel, ushort replyCode, string replyText) -> void +static RabbitMQ.Client.IChannelExtensions.CloseAsync(this RabbitMQ.Client.IChannel channel) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.CloseAsync(this RabbitMQ.Client.IChannel channel, ushort replyCode, string replyText) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.ExchangeBind(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeBindAsync(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.ExchangeBindNoWait(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeDeclare(this RabbitMQ.Client.IChannel channel, string exchange, string type, bool durable = false, bool autoDelete = false, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeDeclareAsync(this RabbitMQ.Client.IChannel channel, string exchange, string type, bool durable = false, bool autoDelete = false, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.ExchangeDeclareNoWait(this RabbitMQ.Client.IChannel channel, string exchange, string type, bool durable = false, bool autoDelete = false, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeDelete(this RabbitMQ.Client.IChannel channel, string exchange, bool ifUnused = false) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeDeleteAsync(this RabbitMQ.Client.IChannel channel, string exchange, bool ifUnused = false) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.ExchangeDeleteNoWait(this RabbitMQ.Client.IChannel channel, string exchange, bool ifUnused = false) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeUnbind(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.ExchangeUnbindAsync(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.QueueBind(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.QueueBindAsync(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.QueueDeclare(this RabbitMQ.Client.IChannel channel, string queue = "", bool durable = false, bool exclusive = true, bool autoDelete = true, System.Collections.Generic.IDictionary arguments = null) -> RabbitMQ.Client.QueueDeclareOk +static RabbitMQ.Client.IChannelExtensions.QueueDeclareAsync(this RabbitMQ.Client.IChannel channel, string queue = "", bool durable = false, bool exclusive = true, bool autoDelete = true, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.QueueDelete(this RabbitMQ.Client.IChannel channel, string queue, bool ifUnused = false, bool ifEmpty = false) -> uint +static RabbitMQ.Client.IChannelExtensions.QueueDeleteAsync(this RabbitMQ.Client.IChannel channel, string queue, bool ifUnused = false, bool ifEmpty = false) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IChannelExtensions.QueueDeleteNoWait(this RabbitMQ.Client.IChannel channel, string queue, bool ifUnused = false, bool ifEmpty = false) -> void +static RabbitMQ.Client.IChannelExtensions.QueueUnbind(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> void +static RabbitMQ.Client.IChannelExtensions.QueueUnbindAsync(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.Abort(this RabbitMQ.Client.IConnection connection) -> void +static RabbitMQ.Client.IConnectionExtensions.Abort(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) -> void +static RabbitMQ.Client.IConnectionExtensions.Abort(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) -> void +static RabbitMQ.Client.IConnectionExtensions.Abort(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) -> void +static RabbitMQ.Client.IConnectionExtensions.AbortAsync(this RabbitMQ.Client.IConnection connection) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.AbortAsync(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.AbortAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.AbortAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.Close(this RabbitMQ.Client.IConnection connection) -> void +static RabbitMQ.Client.IConnectionExtensions.Close(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) -> void +static RabbitMQ.Client.IConnectionExtensions.Close(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) -> void +static RabbitMQ.Client.IConnectionExtensions.Close(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) -> void +static RabbitMQ.Client.IConnectionExtensions.CloseAsync(this RabbitMQ.Client.IConnection connection) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.CloseAsync(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.CloseAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.IConnectionExtensions.CloseAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) -> System.Threading.Tasks.ValueTask +static RabbitMQ.Client.PublicationAddress.Parse(string uriLikeString) -> RabbitMQ.Client.PublicationAddress +static RabbitMQ.Client.PublicationAddress.TryParse(string uriLikeString, out RabbitMQ.Client.PublicationAddress result) -> bool +static RabbitMQ.Client.QueueDeclareOk.implicit operator string(RabbitMQ.Client.QueueDeclareOk declareOk) -> string +static RabbitMQ.Client.TcpClientAdapter.GetMatchingHost(System.Collections.Generic.IReadOnlyCollection addresses, System.Net.Sockets.AddressFamily addressFamily) -> System.Net.IPAddress +static RabbitMQ.Client.TimerBasedCredentialRefresherEventSource.Log.get -> RabbitMQ.Client.TimerBasedCredentialRefresherEventSource +static readonly RabbitMQ.Client.CachedString.Empty -> RabbitMQ.Client.CachedString +static readonly RabbitMQ.Client.ConnectionFactory.DefaultAuthMechanisms -> System.Collections.Generic.IEnumerable +static readonly RabbitMQ.Client.ConnectionFactory.DefaultConnectionTimeout -> System.TimeSpan +static readonly RabbitMQ.Client.ConnectionFactory.DefaultCredentialsRefresher -> RabbitMQ.Client.ICredentialsRefresher +static readonly RabbitMQ.Client.ConnectionFactory.DefaultHeartbeat -> System.TimeSpan +static readonly RabbitMQ.Client.Protocols.AMQP_0_9_1 -> RabbitMQ.Client.IProtocol +static readonly RabbitMQ.Client.Protocols.DefaultProtocol -> RabbitMQ.Client.IProtocol +static readonly RabbitMQ.Client.PublicationAddress.PSEUDO_URI_PARSER -> System.Text.RegularExpressions.Regex +virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicCancel(string consumerTag) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicCancelOk(string consumerTag) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicConsumeOk(string consumerTag) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.AsyncDefaultBasicConsumer.OnCancel(params string[] consumerTags) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.DefaultBasicConsumer.HandleBasicCancel(string consumerTag) -> void +virtual RabbitMQ.Client.DefaultBasicConsumer.HandleBasicCancelOk(string consumerTag) -> void +virtual RabbitMQ.Client.DefaultBasicConsumer.HandleBasicConsumeOk(string consumerTag) -> void +virtual RabbitMQ.Client.DefaultBasicConsumer.HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) -> void +virtual RabbitMQ.Client.DefaultBasicConsumer.HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) -> void +virtual RabbitMQ.Client.DefaultBasicConsumer.OnCancel(params string[] consumerTags) -> void +virtual RabbitMQ.Client.Exceptions.ProtocolException.ShutdownReason.get -> RabbitMQ.Client.ShutdownEventArgs +virtual RabbitMQ.Client.TcpClientAdapter.Client.get -> System.Net.Sockets.Socket +virtual RabbitMQ.Client.TcpClientAdapter.Close() -> void +virtual RabbitMQ.Client.TcpClientAdapter.ConnectAsync(System.Net.IPAddress ep, int port, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task +virtual RabbitMQ.Client.TcpClientAdapter.Connected.get -> bool +virtual RabbitMQ.Client.TcpClientAdapter.Dispose(bool disposing) -> void +virtual RabbitMQ.Client.TcpClientAdapter.GetStream() -> System.Net.Sockets.NetworkStream +virtual RabbitMQ.Client.TcpClientAdapter.ReceiveTimeout.get -> System.TimeSpan +virtual RabbitMQ.Client.TcpClientAdapter.ReceiveTimeout.set -> void diff --git a/projects/RabbitMQ.Client/RabbitMQ.Client.csproj b/projects/RabbitMQ.Client/RabbitMQ.Client.csproj index 5b65ab5ff5..88fb81ef82 100644 --- a/projects/RabbitMQ.Client/RabbitMQ.Client.csproj +++ b/projects/RabbitMQ.Client/RabbitMQ.Client.csproj @@ -66,6 +66,7 @@ + diff --git a/projects/RabbitMQ.Client/client/api/IEndpointResolverExtensions.cs b/projects/RabbitMQ.Client/client/api/IEndpointResolverExtensions.cs index 71679074b4..6f0ca8e7d5 100644 --- a/projects/RabbitMQ.Client/client/api/IEndpointResolverExtensions.cs +++ b/projects/RabbitMQ.Client/client/api/IEndpointResolverExtensions.cs @@ -42,7 +42,7 @@ public static async Task SelectOneAsync(this IEndpointResolver resolver, Func> selector, CancellationToken cancellationToken) { var t = default(T); - List exceptions = []; + var exceptions = new List(); foreach (AmqpTcpEndpoint ep in resolver.All()) { try diff --git a/projects/Test/Common/IntegrationFixtureBase.cs b/projects/Test/Common/IntegrationFixtureBase.cs index 05471a061e..5666494402 100644 --- a/projects/Test/Common/IntegrationFixtureBase.cs +++ b/projects/Test/Common/IntegrationFixtureBase.cs @@ -32,10 +32,14 @@ using System; using System.Collections.Generic; using System.Globalization; +using System.IO; +using System.Linq; +using System.Net.Sockets; using System.Reflection; using System.Text; using System.Threading; using RabbitMQ.Client; +using RabbitMQ.Client.Exceptions; using RabbitMQ.Client.Framing.Impl; using Xunit; using Xunit.Abstractions; @@ -196,22 +200,89 @@ protected static bool IsVerbose get { return s_isVerbose; } } - internal AutorecoveringConnection CreateAutorecoveringConnection(IList hostnames) + internal AutorecoveringConnection CreateAutorecoveringConnection(IEnumerable hostnames, bool expectException = false) { - return CreateAutorecoveringConnection(hostnames, RequestedConnectionTimeout, RecoveryInterval); + return CreateAutorecoveringConnection(hostnames, RequestedConnectionTimeout, RecoveryInterval, expectException); } internal AutorecoveringConnection CreateAutorecoveringConnection(IEnumerable hostnames, - TimeSpan requestedConnectionTimeout, TimeSpan networkRecoveryInterval) - { - ConnectionFactory cf = CreateConnectionFactory(); - cf.AutomaticRecoveryEnabled = true; - // tests that use this helper will likely list unreachable hosts; - // make sure we time out quickly on those - cf.RequestedConnectionTimeout = requestedConnectionTimeout; - cf.NetworkRecoveryInterval = networkRecoveryInterval; - return (AutorecoveringConnection)cf.CreateConnection(hostnames); + TimeSpan requestedConnectionTimeout, TimeSpan networkRecoveryInterval, bool expectException = false) + { + ConnectionFactory ConnectionFactoryConfigurator(ConnectionFactory cf) + { + cf.AutomaticRecoveryEnabled = true; + // tests that use this helper will likely list unreachable hosts; + // make sure we time out quickly on those + cf.RequestedConnectionTimeout = requestedConnectionTimeout; + cf.NetworkRecoveryInterval = networkRecoveryInterval; + return cf; + } + + return (AutorecoveringConnection)CreateConnectionWithRetries(hostnames, ConnectionFactoryConfigurator, expectException); + } + + protected IConnection CreateConnectionWithRetries(Func connectionFactoryConfigurator) + { + var hostnames = new[] { "localhost" }; + return CreateConnectionWithRetries(hostnames, connectionFactoryConfigurator); + } + + protected IConnection CreateConnectionWithRetries(IEnumerable hostnames, + Func connectionFactoryConfigurator, bool expectException = false) + { + bool shouldRetry = IsWindows; + ushort tries = 0; + + do + { + try + { + ConnectionFactory cf0 = CreateConnectionFactory(); + ConnectionFactory cf1 = connectionFactoryConfigurator(cf0); + return cf1.CreateConnection(hostnames); + } + catch (BrokerUnreachableException ex) + { + if (expectException) + { + throw; + } + else + { + IOException ioex = null; + + if (ex.InnerException is AggregateException agex0) + { + AggregateException agex1 = agex0.Flatten(); + ioex = agex1.InnerExceptions.Where(ex => ex is IOException).FirstOrDefault() as IOException; + } + + ioex ??= ex.InnerException as IOException; + + if (ioex is null) + { + throw; + } + else + { + if (ioex.InnerException is SocketException) + { + tries++; + _output.WriteLine($"WARNING: {nameof(CreateConnectionWithRetries)} retrying ({tries}), caught exception: {ioex.InnerException}"); + } + else + { + throw; + } + } + } + } + } + while (shouldRetry && tries < 5); + + Assert.Fail($"FAIL: {nameof(CreateConnectionWithRetries)} could not open connection"); + return null; } protected void WithTemporaryChannel(Action action) diff --git a/projects/Test/Integration/TestInitialConnection.cs b/projects/Test/Integration/TestInitialConnection.cs index b0a34e0d36..c141baa8f5 100644 --- a/projects/Test/Integration/TestInitialConnection.cs +++ b/projects/Test/Integration/TestInitialConnection.cs @@ -68,7 +68,7 @@ public void TestBasicConnectionRecoveryWithHostnameListWithOnlyUnreachableHosts( "191.72.44.22", "145.23.22.18", "192.255.255.255" - }); + }, expectException: true); }); } } diff --git a/projects/Test/Integration/TestSsl.cs b/projects/Test/Integration/TestSsl.cs index 570c2b9c5f..1f38dbb0b0 100644 --- a/projects/Test/Integration/TestSsl.cs +++ b/projects/Test/Integration/TestSsl.cs @@ -29,6 +29,7 @@ // Copyright (c) 2007-2020 VMware, Inc. All rights reserved. //--------------------------------------------------------------------------- +using System; using System.IO; using System.Net.Security; using System.Security.Authentication; @@ -59,13 +60,16 @@ public void TestServerVerifiedIgnoringNameMismatch() { Skip.IfNot(_sslEnv.IsSslConfigured, "SSL_CERTS_DIR and/or PASSWORD are not configured, skipping test"); - var cf = CreateConnectionFactory(); - cf.Port = 5671; + ConnectionFactory ConnectionFactoryConfigurator(ConnectionFactory cf) + { + cf.Port = 5671; + cf.Ssl.ServerName = "*"; + cf.Ssl.AcceptablePolicyErrors = SslPolicyErrors.RemoteCertificateNameMismatch; + cf.Ssl.Enabled = true; + return cf; + } - cf.Ssl.ServerName = "*"; - cf.Ssl.AcceptablePolicyErrors = SslPolicyErrors.RemoteCertificateNameMismatch; - cf.Ssl.Enabled = true; - SendReceive(cf); + SendReceive(ConnectionFactoryConfigurator); } [SkippableFact] @@ -73,11 +77,15 @@ public void TestServerVerified() { Skip.IfNot(_sslEnv.IsSslConfigured, "SSL_CERTS_DIR and/or PASSWORD are not configured, skipping test"); - var cf = CreateConnectionFactory(); - cf.Port = 5671; - cf.Ssl.ServerName = _sslEnv.Hostname; - cf.Ssl.Enabled = true; - SendReceive(cf); + ConnectionFactory ConnectionFactoryConfigurator(ConnectionFactory cf) + { + cf.Port = 5671; + cf.Ssl.ServerName = _sslEnv.Hostname; + cf.Ssl.Enabled = true; + return cf; + } + + SendReceive(ConnectionFactoryConfigurator); } [SkippableFact] @@ -88,13 +96,17 @@ public void TestClientAndServerVerified() string certPath = _sslEnv.CertPath; Assert.True(File.Exists(certPath)); - var cf = CreateConnectionFactory(); - cf.Port = 5671; - cf.Ssl.ServerName = _sslEnv.Hostname; - cf.Ssl.CertPath = certPath; - cf.Ssl.CertPassphrase = _sslEnv.CertPassphrase; - cf.Ssl.Enabled = true; - SendReceive(cf); + ConnectionFactory ConnectionFactoryConfigurator(ConnectionFactory cf) + { + cf.Port = 5671; + cf.Ssl.ServerName = _sslEnv.Hostname; + cf.Ssl.CertPath = certPath; + cf.Ssl.CertPassphrase = _sslEnv.CertPassphrase; + cf.Ssl.Enabled = true; + return cf; + } + + SendReceive(ConnectionFactoryConfigurator); } // rabbitmq/rabbitmq-dotnet-client#46, also #44 and #45 @@ -103,25 +115,28 @@ public void TestNoClientCertificate() { Skip.IfNot(_sslEnv.IsSslConfigured, "SSL_CERTS_DIR and/or PASSWORD are not configured, skipping test"); - var cf = CreateConnectionFactory(); - cf.Port = 5671; - cf.Ssl = new SslOption() + ConnectionFactory ConnectionFactoryConfigurator(ConnectionFactory cf) { - CertPath = null, - Enabled = true, - ServerName = _sslEnv.Hostname, - Version = SslProtocols.None, - AcceptablePolicyErrors = - SslPolicyErrors.RemoteCertificateNotAvailable | - SslPolicyErrors.RemoteCertificateNameMismatch - }; - - SendReceive(cf); + cf.Port = 5671; + cf.Ssl = new SslOption() + { + CertPath = null, + Enabled = true, + ServerName = _sslEnv.Hostname, + Version = SslProtocols.None, + AcceptablePolicyErrors = + SslPolicyErrors.RemoteCertificateNotAvailable | + SslPolicyErrors.RemoteCertificateNameMismatch + }; + return cf; + } + + SendReceive(ConnectionFactoryConfigurator); } - private void SendReceive(ConnectionFactory cf) + private void SendReceive(Func cfconfig) { - using (IConnection conn = cf.CreateConnection(_testDisplayName)) + using (IConnection conn = CreateConnectionWithRetries(cfconfig)) { using (IChannel ch = conn.CreateChannel()) { diff --git a/projects/Test/OAuth2/APIApproval.Approve.verified.txt b/projects/Test/OAuth2/APIApproval.Approve.verified.txt deleted file mode 100644 index d1a77036a1..0000000000 --- a/projects/Test/OAuth2/APIApproval.Approve.verified.txt +++ /dev/null @@ -1,50 +0,0 @@ -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Unit, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -namespace RabbitMQ.Client.OAuth2 -{ - public interface IOAuth2Client - { - RabbitMQ.Client.OAuth2.IToken RefreshToken(RabbitMQ.Client.OAuth2.IToken token); - RabbitMQ.Client.OAuth2.IToken RequestToken(); - } - public interface IToken - { - string AccessToken { get; } - System.TimeSpan ExpiresIn { get; } - string RefreshToken { get; } - bool hasExpired { get; } - } - public class JsonToken - { - public JsonToken() { } - public JsonToken(string access_token, string refresh_token, long expires_in) { } - public JsonToken(string access_token, string refresh_token, System.TimeSpan expires_in_span) { } - public string access_token { get; set; } - public long expires_in { get; set; } - public string refresh_token { get; set; } - } - public class OAuth2ClientBuilder - { - public OAuth2ClientBuilder(string clientId, string clientSecret, System.Uri tokenEndpoint) { } - public RabbitMQ.Client.OAuth2.OAuth2ClientBuilder AddRequestParameter(string param, string paramValue) { } - public RabbitMQ.Client.OAuth2.IOAuth2Client Build() { } - public RabbitMQ.Client.OAuth2.OAuth2ClientBuilder SetHttpClientHandler(System.Net.Http.HttpClientHandler handler) { } - public RabbitMQ.Client.OAuth2.OAuth2ClientBuilder SetScope(string scope) { } - } - public class OAuth2ClientCredentialsProvider : RabbitMQ.Client.ICredentialsProvider - { - public OAuth2ClientCredentialsProvider(string name, RabbitMQ.Client.OAuth2.IOAuth2Client oAuth2Client) { } - public string Name { get; } - public string Password { get; } - public string UserName { get; } - public System.TimeSpan? ValidUntil { get; } - public void Refresh() { } - } - public class Token : RabbitMQ.Client.OAuth2.IToken - { - public Token(RabbitMQ.Client.OAuth2.JsonToken json) { } - public string AccessToken { get; } - public System.TimeSpan ExpiresIn { get; } - public string RefreshToken { get; } - } -} \ No newline at end of file diff --git a/projects/Test/OAuth2/APIApproval.cs b/projects/Test/OAuth2/APIApproval.cs deleted file mode 100644 index 055899e4c8..0000000000 --- a/projects/Test/OAuth2/APIApproval.cs +++ /dev/null @@ -1,63 +0,0 @@ -// This source code is dual-licensed under the Apache License, version -// 2.0, and the Mozilla Public License, version 2.0. -// -// The APL v2.0: -// -//--------------------------------------------------------------------------- -// Copyright (c) 2007-2020 VMware, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// https://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -//--------------------------------------------------------------------------- -// -// The MPL v2.0: -// -//--------------------------------------------------------------------------- -// This Source Code Form is subject to the terms of the Mozilla Public -// License, v. 2.0. If a copy of the MPL was not distributed with this -// file, You can obtain one at https://mozilla.org/MPL/2.0/. -// -// Copyright (c) 2007-2020 VMware, Inc. All rights reserved. -//--------------------------------------------------------------------------- - -using System; -using System.Threading.Tasks; -using PublicApiGenerator; -using VerifyTests; -using VerifyXunit; -using Xunit; - -namespace OAuth2Test -{ - [UsesVerify] - public class APIApproval - { - private static readonly ApiGeneratorOptions opts = new ApiGeneratorOptions - { - ExcludeAttributes = new[] - { - "System.Runtime.Versioning.TargetFrameworkAttribute", - "System.Reflection.AssemblyMetadataAttribute" - } - }; - - [Fact] - public Task Approve() - { - Type apiType = typeof(RabbitMQ.Client.OAuth2.IOAuth2Client); - string publicApi = apiType.Assembly.GeneratePublicApi(opts); - var settings = new VerifySettings(); - settings.DisableDiff(); - return Verifier.Verify(publicApi, settings); - } - } -} diff --git a/projects/Test/OAuth2/OAuth2.csproj b/projects/Test/OAuth2/OAuth2.csproj index c0a8180246..f7f9b8d2fa 100644 --- a/projects/Test/OAuth2/OAuth2.csproj +++ b/projects/Test/OAuth2/OAuth2.csproj @@ -22,20 +22,12 @@ - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - + - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - + - diff --git a/projects/Test/Unit/APIApproval.Approve.verified.txt b/projects/Test/Unit/APIApproval.Approve.verified.txt deleted file mode 100644 index 737bf6ad69..0000000000 --- a/projects/Test/Unit/APIApproval.Approve.verified.txt +++ /dev/null @@ -1,1147 +0,0 @@ -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"AsyncIntegration, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Benchmarks, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Common, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Integration, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"SequentialIntegration, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -[assembly: System.Runtime.CompilerServices.InternalsVisibleTo(@"Unit, PublicKey=00240000048000009400000006020000002400005253413100040000010001008d20ec856aeeb8c3153a77faa2d80e6e43b5db93224a20cc7ae384f65f142e89730e2ff0fcc5d578bbe96fa98a7196c77329efdee4579b3814c0789e5a39b51df6edd75b602a33ceabdfcf19a3feb832f31d8254168cd7ba5700dfbca301fbf8db614ba41ba18474de0a5f4c2d51c995bc3636c641c8cbe76f45717bfcb943b5")] -namespace RabbitMQ.Client -{ - public class AmqpTcpEndpoint - { - public const int DefaultAmqpSslPort = 5671; - public const int UseDefaultPort = -1; - public AmqpTcpEndpoint() { } - public AmqpTcpEndpoint(System.Uri uri) { } - public AmqpTcpEndpoint(string hostName, int portOrMinusOne = -1) { } - public AmqpTcpEndpoint(System.Uri uri, RabbitMQ.Client.SslOption ssl) { } - public AmqpTcpEndpoint(string hostName, int portOrMinusOne, RabbitMQ.Client.SslOption ssl) { } - public AmqpTcpEndpoint(string hostName, int portOrMinusOne, RabbitMQ.Client.SslOption ssl, uint maxMessageSize) { } - public System.Net.Sockets.AddressFamily AddressFamily { get; set; } - public string HostName { get; set; } - public uint MaxMessageSize { get; } - public int Port { get; set; } - public RabbitMQ.Client.IProtocol Protocol { get; } - public RabbitMQ.Client.SslOption Ssl { get; set; } - public object Clone() { } - public RabbitMQ.Client.AmqpTcpEndpoint CloneWithHostname(string hostname) { } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static RabbitMQ.Client.AmqpTcpEndpoint Parse(string address) { } - public static RabbitMQ.Client.AmqpTcpEndpoint[] ParseMultiple(string addresses) { } - } - public readonly struct AmqpTimestamp : System.IEquatable - { - public readonly long UnixTime; - public AmqpTimestamp(long unixTime) { } - public bool Equals(RabbitMQ.Client.AmqpTimestamp other) { } - public override bool Equals(object obj) { } - public override int GetHashCode() { } - public override string ToString() { } - public static bool operator !=(RabbitMQ.Client.AmqpTimestamp left, RabbitMQ.Client.AmqpTimestamp right) { } - public static bool operator ==(RabbitMQ.Client.AmqpTimestamp left, RabbitMQ.Client.AmqpTimestamp right) { } - } - public class AsyncDefaultBasicConsumer : RabbitMQ.Client.IAsyncBasicConsumer, RabbitMQ.Client.IBasicConsumer - { - public AsyncDefaultBasicConsumer() { } - public AsyncDefaultBasicConsumer(RabbitMQ.Client.IChannel channel) { } - public RabbitMQ.Client.IChannel Channel { get; set; } - public string[] ConsumerTags { get; } - public bool IsRunning { get; set; } - public RabbitMQ.Client.ShutdownEventArgs ShutdownReason { get; set; } - public event RabbitMQ.Client.Events.AsyncEventHandler ConsumerCancelled; - public virtual System.Threading.Tasks.Task HandleBasicCancel(string consumerTag) { } - public virtual System.Threading.Tasks.Task HandleBasicCancelOk(string consumerTag) { } - public virtual System.Threading.Tasks.Task HandleBasicConsumeOk(string consumerTag) { } - public virtual System.Threading.Tasks.Task HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) { } - public virtual System.Threading.Tasks.Task HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) { } - public virtual System.Threading.Tasks.Task OnCancel(params string[] consumerTags) { } - } - public class BasicCredentialsProvider : RabbitMQ.Client.ICredentialsProvider - { - public BasicCredentialsProvider(string name, string userName, string password) { } - public string Name { get; } - public string Password { get; } - public string UserName { get; } - public System.TimeSpan? ValidUntil { get; } - public void Refresh() { } - } - public sealed class BasicGetResult - { - public readonly RabbitMQ.Client.ReadOnlyBasicProperties BasicProperties; - public readonly System.ReadOnlyMemory Body; - public readonly ulong DeliveryTag; - public readonly string Exchange; - public readonly uint MessageCount; - public readonly bool Redelivered; - public readonly string RoutingKey; - public BasicGetResult(ulong deliveryTag, bool redelivered, string exchange, string routingKey, uint messageCount, in RabbitMQ.Client.ReadOnlyBasicProperties basicProperties, System.ReadOnlyMemory body) { } - } - public struct BasicProperties : RabbitMQ.Client.IAmqpHeader, RabbitMQ.Client.IAmqpWriteable, RabbitMQ.Client.IBasicProperties, RabbitMQ.Client.IReadOnlyBasicProperties - { - public BasicProperties(in RabbitMQ.Client.ReadOnlyBasicProperties input) { } - public string? AppId { get; set; } - public string? ClusterId { get; set; } - public string? ContentEncoding { get; set; } - public string? ContentType { get; set; } - public string? CorrelationId { get; set; } - public RabbitMQ.Client.DeliveryModes DeliveryMode { get; set; } - public string? Expiration { get; set; } - public System.Collections.Generic.IDictionary? Headers { get; set; } - public string? MessageId { get; set; } - public bool Persistent { get; set; } - public byte Priority { get; set; } - public string? ReplyTo { get; set; } - public RabbitMQ.Client.PublicationAddress? ReplyToAddress { get; set; } - public RabbitMQ.Client.AmqpTimestamp Timestamp { get; set; } - public string? Type { get; set; } - public string? UserId { get; set; } - public void ClearAppId() { } - public void ClearClusterId() { } - public void ClearContentEncoding() { } - public void ClearContentType() { } - public void ClearCorrelationId() { } - public void ClearDeliveryMode() { } - public void ClearExpiration() { } - public void ClearHeaders() { } - public void ClearMessageId() { } - public void ClearPriority() { } - public void ClearReplyTo() { } - public void ClearTimestamp() { } - public void ClearType() { } - public void ClearUserId() { } - public bool IsAppIdPresent() { } - public bool IsClusterIdPresent() { } - public bool IsContentEncodingPresent() { } - public bool IsContentTypePresent() { } - public bool IsCorrelationIdPresent() { } - public bool IsDeliveryModePresent() { } - public bool IsExpirationPresent() { } - public bool IsHeadersPresent() { } - public bool IsMessageIdPresent() { } - public bool IsPriorityPresent() { } - public bool IsReplyToPresent() { } - public bool IsTimestampPresent() { } - public bool IsTypePresent() { } - public bool IsUserIdPresent() { } - } - public class BinaryTableValue - { - public BinaryTableValue() { } - public BinaryTableValue(byte[] bytes) { } - public byte[] Bytes { get; set; } - } - public sealed class CachedString - { - public readonly System.ReadOnlyMemory Bytes; - public readonly string Value; - public static readonly RabbitMQ.Client.CachedString Empty; - public CachedString(System.ReadOnlyMemory bytes) { } - public CachedString(string value) { } - public CachedString(string value, System.ReadOnlyMemory bytes) { } - } - public sealed class ConnectionConfig - { - public readonly System.Collections.Generic.IEnumerable AuthMechanisms; - public readonly System.Collections.Generic.IDictionary ClientProperties; - public readonly string? ClientProvidedName; - public readonly System.TimeSpan ContinuationTimeout; - public RabbitMQ.Client.ICredentialsProvider CredentialsProvider; - public RabbitMQ.Client.ICredentialsRefresher CredentialsRefresher; - public readonly int DispatchConsumerConcurrency; - public readonly bool DispatchConsumersAsync; - public readonly System.TimeSpan HandshakeContinuationTimeout; - public readonly System.TimeSpan HeartbeatInterval; - public readonly ushort MaxChannelCount; - public readonly uint MaxFrameSize; - public readonly System.TimeSpan NetworkRecoveryInterval; - public readonly string Password; - public readonly System.TimeSpan RequestedConnectionTimeout; - public readonly bool TopologyRecoveryEnabled; - public readonly RabbitMQ.Client.TopologyRecoveryExceptionHandler TopologyRecoveryExceptionHandler; - public readonly RabbitMQ.Client.TopologyRecoveryFilter TopologyRecoveryFilter; - public readonly string UserName; - public readonly string VirtualHost; - } - public sealed class ConnectionFactory : RabbitMQ.Client.ConnectionFactoryBase, RabbitMQ.Client.IConnectionFactory - { - public const ushort DefaultChannelMax = 2047; - public const uint DefaultFrameMax = 0u; - public const uint DefaultMaxMessageSize = 134217728u; - public const string DefaultPass = "guest"; - public const string DefaultUser = "guest"; - public const string DefaultVHost = "/"; - public const uint MaximumMaxMessageSize = 536870912u; - public static readonly System.Collections.Generic.IEnumerable DefaultAuthMechanisms; - public static readonly System.TimeSpan DefaultConnectionTimeout; - public static readonly RabbitMQ.Client.ICredentialsRefresher DefaultCredentialsRefresher; - public static readonly System.TimeSpan DefaultHeartbeat; - public ConnectionFactory() { } - public System.Security.Authentication.SslProtocols AmqpUriSslProtocols { get; set; } - public System.Collections.Generic.IEnumerable AuthMechanisms { get; set; } - public bool AutomaticRecoveryEnabled { get; set; } - public System.Collections.Generic.IDictionary ClientProperties { get; set; } - public string ClientProvidedName { get; set; } - public int ConsumerDispatchConcurrency { get; set; } - public System.TimeSpan ContinuationTimeout { get; set; } - public RabbitMQ.Client.ICredentialsProvider CredentialsProvider { get; set; } - public RabbitMQ.Client.ICredentialsRefresher CredentialsRefresher { get; set; } - public bool DispatchConsumersAsync { get; set; } - public RabbitMQ.Client.AmqpTcpEndpoint Endpoint { get; set; } - public System.Func, RabbitMQ.Client.IEndpointResolver> EndpointResolverFactory { get; set; } - public System.TimeSpan HandshakeContinuationTimeout { get; set; } - public string HostName { get; set; } - public uint MaxMessageSize { get; set; } - public System.TimeSpan NetworkRecoveryInterval { get; set; } - public string Password { get; set; } - public int Port { get; set; } - public ushort RequestedChannelMax { get; set; } - public System.TimeSpan RequestedConnectionTimeout { get; set; } - public uint RequestedFrameMax { get; set; } - public System.TimeSpan RequestedHeartbeat { get; set; } - public System.TimeSpan SocketReadTimeout { get; set; } - public System.TimeSpan SocketWriteTimeout { get; set; } - public RabbitMQ.Client.SslOption Ssl { get; set; } - public bool TopologyRecoveryEnabled { get; set; } - public RabbitMQ.Client.TopologyRecoveryExceptionHandler TopologyRecoveryExceptionHandler { get; set; } - public RabbitMQ.Client.TopologyRecoveryFilter TopologyRecoveryFilter { get; set; } - public System.Uri Uri { get; set; } - public string UserName { get; set; } - public string VirtualHost { get; set; } - public static System.Net.Sockets.AddressFamily DefaultAddressFamily { get; set; } - public static System.Security.Authentication.SslProtocols DefaultAmqpUriSslProtocols { get; set; } - public RabbitMQ.Client.IAuthMechanismFactory AuthMechanismFactory(System.Collections.Generic.IEnumerable argServerMechanismNames) { } - public RabbitMQ.Client.IConnection CreateConnection() { } - public RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable endpoints) { } - public RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable hostnames) { } - public RabbitMQ.Client.IConnection CreateConnection(string clientProvidedName) { } - public RabbitMQ.Client.IConnection CreateConnection(RabbitMQ.Client.IEndpointResolver endpointResolver, string clientProvidedName) { } - public RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName) { } - public RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Threading.CancellationToken cancellationToken = default) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, System.Threading.CancellationToken cancellationToken = default) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, System.Threading.CancellationToken cancellationToken = default) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(string clientProvidedName, System.Threading.CancellationToken cancellationToken = default) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(RabbitMQ.Client.IEndpointResolver endpointResolver, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default) { } - public System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default) { } - } - public class ConnectionFactoryBase - { - public System.Func SocketFactory; - public ConnectionFactoryBase() { } - public static RabbitMQ.Client.ITcpClient DefaultSocketFactory(System.Net.Sockets.AddressFamily addressFamily) { } - } - public static class Constants - { - public const int AccessRefused = 403; - public const int ChannelError = 504; - public const int CommandInvalid = 503; - public const int ConnectionForced = 320; - public const int ContentTooLarge = 311; - public const int FrameBody = 3; - public const int FrameEnd = 206; - public const int FrameError = 501; - public const int FrameHeader = 2; - public const int FrameHeartbeat = 8; - public const int FrameMethod = 1; - public const int FrameMinSize = 4096; - public const int InternalError = 541; - public const int InvalidPath = 402; - public const int NoConsumers = 313; - public const int NoRoute = 312; - public const int NotAllowed = 530; - public const int NotFound = 404; - public const int NotImplemented = 540; - public const int PreconditionFailed = 406; - public const int ReplySuccess = 200; - public const int ResourceError = 506; - public const int ResourceLocked = 405; - public const int SyntaxError = 502; - public const int UnexpectedFrame = 505; - } - public class DefaultBasicConsumer : RabbitMQ.Client.IBasicConsumer - { - public DefaultBasicConsumer() { } - public DefaultBasicConsumer(RabbitMQ.Client.IChannel channel) { } - public RabbitMQ.Client.IChannel Channel { get; set; } - public string[] ConsumerTags { get; } - public bool IsRunning { get; set; } - public RabbitMQ.Client.ShutdownEventArgs ShutdownReason { get; set; } - public event System.EventHandler ConsumerCancelled; - public virtual void HandleBasicCancel(string consumerTag) { } - public virtual void HandleBasicCancelOk(string consumerTag) { } - public virtual void HandleBasicConsumeOk(string consumerTag) { } - public virtual void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) { } - public virtual void HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) { } - public virtual void OnCancel(params string[] consumerTags) { } - } - public class DefaultEndpointResolver : RabbitMQ.Client.IEndpointResolver - { - public DefaultEndpointResolver(System.Collections.Generic.IEnumerable tcpEndpoints) { } - public System.Collections.Generic.IEnumerable All() { } - } - public enum DeliveryModes : byte - { - Transient = 1, - Persistent = 2, - } - public static class EndpointResolverExtensions - { - public static System.Threading.Tasks.Task SelectOneAsync(this RabbitMQ.Client.IEndpointResolver resolver, System.Func> selector, System.Threading.CancellationToken cancellationToken) { } - } - public static class ExchangeType - { - public const string Direct = "direct"; - public const string Fanout = "fanout"; - public const string Headers = "headers"; - public const string Topic = "topic"; - public static System.Collections.Generic.ICollection All() { } - } - public class ExternalMechanism : RabbitMQ.Client.IAuthMechanism - { - public ExternalMechanism() { } - public byte[] handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) { } - } - public class ExternalMechanismFactory : RabbitMQ.Client.IAuthMechanismFactory - { - public ExternalMechanismFactory() { } - public string Name { get; } - public RabbitMQ.Client.IAuthMechanism GetInstance() { } - } - public static class Headers - { - public const string AlternateExchange = "alternate-exchange"; - public const string XDeadLetterExchange = "x-dead-letter-exchange"; - public const string XDeadLetterRoutingKey = "x-dead-letter-routing-key"; - public const string XExpires = "x-expires"; - public const string XMaxAge = "x-max-age"; - public const string XMaxLength = "x-max-length"; - public const string XMaxLengthInBytes = "x-max-length-bytes"; - public const string XMaxPriority = "x-max-priority"; - public const string XMessageTTL = "x-message-ttl"; - public const string XOverflow = "x-overflow"; - public const string XPriority = "x-priority"; - public const string XQueueMode = "x-queue-mode"; - public const string XQueueType = "x-queue-type"; - public const string XQuorumInitialGroupSize = "x-quorum-initial-group-size"; - public const string XSingleActiveConsumer = "x-single-active-consumer"; - public const string XStreamMaxSegmentSizeInBytes = "x-stream-max-segment-size-bytes"; - public const string XStreamOffset = "x-stream-offset"; - } - public interface IAmqpHeader : RabbitMQ.Client.IAmqpWriteable - { - ushort ProtocolClassId { get; } - } - public interface IAmqpWriteable - { - int GetRequiredBufferSize(); - int WriteTo(System.Span span); - } - public interface IAsyncBasicConsumer - { - RabbitMQ.Client.IChannel Channel { get; } - event RabbitMQ.Client.Events.AsyncEventHandler ConsumerCancelled; - System.Threading.Tasks.Task HandleBasicCancel(string consumerTag); - System.Threading.Tasks.Task HandleBasicCancelOk(string consumerTag); - System.Threading.Tasks.Task HandleBasicConsumeOk(string consumerTag); - System.Threading.Tasks.Task HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body); - System.Threading.Tasks.Task HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason); - } - public interface IAuthMechanism - { - byte[] handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config); - } - public interface IAuthMechanismFactory - { - string Name { get; } - RabbitMQ.Client.IAuthMechanism GetInstance(); - } - public interface IBasicConsumer - { - RabbitMQ.Client.IChannel Channel { get; } - event System.EventHandler ConsumerCancelled; - void HandleBasicCancel(string consumerTag); - void HandleBasicCancelOk(string consumerTag); - void HandleBasicConsumeOk(string consumerTag); - void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body); - void HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason); - } - public interface IBasicProperties : RabbitMQ.Client.IReadOnlyBasicProperties - { - new string? AppId { get; set; } - new string? ClusterId { get; set; } - new string? ContentEncoding { get; set; } - new string? ContentType { get; set; } - new string? CorrelationId { get; set; } - new RabbitMQ.Client.DeliveryModes DeliveryMode { get; set; } - new string? Expiration { get; set; } - new System.Collections.Generic.IDictionary? Headers { get; set; } - new string? MessageId { get; set; } - new bool Persistent { get; set; } - new byte Priority { get; set; } - new string? ReplyTo { get; set; } - new RabbitMQ.Client.PublicationAddress? ReplyToAddress { get; set; } - new RabbitMQ.Client.AmqpTimestamp Timestamp { get; set; } - new string? Type { get; set; } - new string? UserId { get; set; } - void ClearAppId(); - void ClearClusterId(); - void ClearContentEncoding(); - void ClearContentType(); - void ClearCorrelationId(); - void ClearDeliveryMode(); - void ClearExpiration(); - void ClearHeaders(); - void ClearMessageId(); - void ClearPriority(); - void ClearReplyTo(); - void ClearTimestamp(); - void ClearType(); - void ClearUserId(); - } - public interface IChannel : System.IDisposable - { - int ChannelNumber { get; } - RabbitMQ.Client.ShutdownEventArgs CloseReason { get; } - System.TimeSpan ContinuationTimeout { get; set; } - string CurrentQueue { get; } - RabbitMQ.Client.IBasicConsumer DefaultConsumer { get; set; } - bool IsClosed { get; } - bool IsOpen { get; } - ulong NextPublishSeqNo { get; } - event System.EventHandler BasicAcks; - event System.EventHandler BasicNacks; - event System.EventHandler BasicReturn; - event System.EventHandler CallbackException; - event System.EventHandler ChannelShutdown; - event System.EventHandler FlowControl; - void BasicAck(ulong deliveryTag, bool multiple); - System.Threading.Tasks.ValueTask BasicAckAsync(ulong deliveryTag, bool multiple); - void BasicCancel(string consumerTag); - System.Threading.Tasks.ValueTask BasicCancelAsync(string consumerTag); - void BasicCancelNoWait(string consumerTag); - string BasicConsume(string queue, bool autoAck, string consumerTag, bool noLocal, bool exclusive, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer); - System.Threading.Tasks.ValueTask BasicConsumeAsync(string queue, bool autoAck, string consumerTag, bool noLocal, bool exclusive, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer); - RabbitMQ.Client.BasicGetResult BasicGet(string queue, bool autoAck); - System.Threading.Tasks.ValueTask BasicGetAsync(string queue, bool autoAck); - void BasicNack(ulong deliveryTag, bool multiple, bool requeue); - System.Threading.Tasks.ValueTask BasicNackAsync(ulong deliveryTag, bool multiple, bool requeue); - void BasicPublish(RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default, bool mandatory = false) - where TProperties : RabbitMQ.Client.IReadOnlyBasicProperties, RabbitMQ.Client.IAmqpHeader; - void BasicPublish(string exchange, string routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default, bool mandatory = false) - where TProperties : RabbitMQ.Client.IReadOnlyBasicProperties, RabbitMQ.Client.IAmqpHeader; - System.Threading.Tasks.ValueTask BasicPublishAsync(RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default, bool mandatory = false) - where TProperties : RabbitMQ.Client.IReadOnlyBasicProperties, RabbitMQ.Client.IAmqpHeader; - System.Threading.Tasks.ValueTask BasicPublishAsync(string exchange, string routingKey, in TProperties basicProperties, System.ReadOnlyMemory body = default, bool mandatory = false) - where TProperties : RabbitMQ.Client.IReadOnlyBasicProperties, RabbitMQ.Client.IAmqpHeader; - void BasicQos(uint prefetchSize, ushort prefetchCount, bool global); - System.Threading.Tasks.ValueTask BasicQosAsync(uint prefetchSize, ushort prefetchCount, bool global); - void BasicReject(ulong deliveryTag, bool requeue); - System.Threading.Tasks.ValueTask BasicRejectAsync(ulong deliveryTag, bool requeue); - void Close(ushort replyCode, string replyText, bool abort); - System.Threading.Tasks.ValueTask CloseAsync(RabbitMQ.Client.ShutdownEventArgs reason, bool abort); - System.Threading.Tasks.ValueTask CloseAsync(ushort replyCode, string replyText, bool abort); - void ConfirmSelect(); - System.Threading.Tasks.ValueTask ConfirmSelectAsync(); - uint ConsumerCount(string queue); - void ExchangeBind(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments); - System.Threading.Tasks.ValueTask ExchangeBindAsync(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments); - void ExchangeBindNoWait(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments); - void ExchangeDeclare(string exchange, string type, bool durable, bool autoDelete, System.Collections.Generic.IDictionary arguments); - System.Threading.Tasks.ValueTask ExchangeDeclareAsync(string exchange, string type, bool passive, bool durable, bool autoDelete, System.Collections.Generic.IDictionary arguments); - void ExchangeDeclareNoWait(string exchange, string type, bool durable, bool autoDelete, System.Collections.Generic.IDictionary arguments); - void ExchangeDeclarePassive(string exchange); - void ExchangeDelete(string exchange, bool ifUnused); - System.Threading.Tasks.ValueTask ExchangeDeleteAsync(string exchange, bool ifUnused); - void ExchangeDeleteNoWait(string exchange, bool ifUnused); - void ExchangeUnbind(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments); - System.Threading.Tasks.ValueTask ExchangeUnbindAsync(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments); - void ExchangeUnbindNoWait(string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments); - uint MessageCount(string queue); - void QueueBind(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments); - System.Threading.Tasks.ValueTask QueueBindAsync(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments); - void QueueBindNoWait(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments); - RabbitMQ.Client.QueueDeclareOk QueueDeclare(string queue, bool durable, bool exclusive, bool autoDelete, System.Collections.Generic.IDictionary arguments); - System.Threading.Tasks.ValueTask QueueDeclareAsync(string queue, bool passive, bool durable, bool exclusive, bool autoDelete, System.Collections.Generic.IDictionary arguments); - void QueueDeclareNoWait(string queue, bool durable, bool exclusive, bool autoDelete, System.Collections.Generic.IDictionary arguments); - RabbitMQ.Client.QueueDeclareOk QueueDeclarePassive(string queue); - uint QueueDelete(string queue, bool ifUnused, bool ifEmpty); - System.Threading.Tasks.ValueTask QueueDeleteAsync(string queue, bool ifUnused, bool ifEmpty); - void QueueDeleteNoWait(string queue, bool ifUnused, bool ifEmpty); - uint QueuePurge(string queue); - System.Threading.Tasks.ValueTask QueuePurgeAsync(string queue); - void QueueUnbind(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments); - System.Threading.Tasks.ValueTask QueueUnbindAsync(string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments); - void TxCommit(); - System.Threading.Tasks.ValueTask TxCommitAsync(); - void TxRollback(); - System.Threading.Tasks.ValueTask TxRollbackAsync(); - void TxSelect(); - System.Threading.Tasks.ValueTask TxSelectAsync(); - System.Threading.Tasks.Task WaitForConfirmsAsync(System.Threading.CancellationToken token = default); - System.Threading.Tasks.Task WaitForConfirmsOrDieAsync(System.Threading.CancellationToken token = default); - } - public static class IChannelExtensions - { - public static void Abort(this RabbitMQ.Client.IChannel channel) { } - public static void Abort(this RabbitMQ.Client.IChannel channel, ushort replyCode, string replyText) { } - public static System.Threading.Tasks.ValueTask AbortAsync(this RabbitMQ.Client.IChannel channel) { } - public static string BasicConsume(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, RabbitMQ.Client.IBasicConsumer consumer) { } - public static string BasicConsume(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, RabbitMQ.Client.IBasicConsumer consumer) { } - public static string BasicConsume(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer) { } - public static string BasicConsume(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.IBasicConsumer consumer, string queue, bool autoAck = false, string consumerTag = "", bool noLocal = false, bool exclusive = false, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, RabbitMQ.Client.IBasicConsumer consumer) { } - public static System.Threading.Tasks.ValueTask BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, RabbitMQ.Client.IBasicConsumer consumer) { } - public static System.Threading.Tasks.ValueTask BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, string queue, bool autoAck, string consumerTag, System.Collections.Generic.IDictionary arguments, RabbitMQ.Client.IBasicConsumer consumer) { } - public static System.Threading.Tasks.ValueTask BasicConsumeAsync(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.IBasicConsumer consumer, string queue, bool autoAck = false, string consumerTag = "", bool noLocal = false, bool exclusive = false, System.Collections.Generic.IDictionary arguments = null) { } - public static void BasicPublish(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, System.ReadOnlyMemory body = default, bool mandatory = false) { } - public static void BasicPublish(this RabbitMQ.Client.IChannel channel, string exchange, string routingKey, System.ReadOnlyMemory body = default, bool mandatory = false) { } - public static void BasicPublish(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.PublicationAddress addr, in T basicProperties, System.ReadOnlyMemory body) - where T : RabbitMQ.Client.IReadOnlyBasicProperties, RabbitMQ.Client.IAmqpHeader { } - public static System.Threading.Tasks.ValueTask BasicPublishAsync(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.CachedString exchange, RabbitMQ.Client.CachedString routingKey, System.ReadOnlyMemory body = default, bool mandatory = false) { } - public static System.Threading.Tasks.ValueTask BasicPublishAsync(this RabbitMQ.Client.IChannel channel, string exchange, string routingKey, System.ReadOnlyMemory body = default, bool mandatory = false) { } - public static System.Threading.Tasks.ValueTask BasicPublishAsync(this RabbitMQ.Client.IChannel channel, RabbitMQ.Client.PublicationAddress addr, in T basicProperties, System.ReadOnlyMemory body) - where T : RabbitMQ.Client.IReadOnlyBasicProperties, RabbitMQ.Client.IAmqpHeader { } - public static void Close(this RabbitMQ.Client.IChannel channel) { } - public static void Close(this RabbitMQ.Client.IChannel channel, ushort replyCode, string replyText) { } - public static System.Threading.Tasks.ValueTask CloseAsync(this RabbitMQ.Client.IChannel channel) { } - public static System.Threading.Tasks.ValueTask CloseAsync(this RabbitMQ.Client.IChannel channel, ushort replyCode, string replyText) { } - public static void ExchangeBind(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask ExchangeBindAsync(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static void ExchangeBindNoWait(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static void ExchangeDeclare(this RabbitMQ.Client.IChannel channel, string exchange, string type, bool durable = false, bool autoDelete = false, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask ExchangeDeclareAsync(this RabbitMQ.Client.IChannel channel, string exchange, string type, bool durable = false, bool autoDelete = false, System.Collections.Generic.IDictionary arguments = null) { } - public static void ExchangeDeclareNoWait(this RabbitMQ.Client.IChannel channel, string exchange, string type, bool durable = false, bool autoDelete = false, System.Collections.Generic.IDictionary arguments = null) { } - public static void ExchangeDelete(this RabbitMQ.Client.IChannel channel, string exchange, bool ifUnused = false) { } - public static System.Threading.Tasks.ValueTask ExchangeDeleteAsync(this RabbitMQ.Client.IChannel channel, string exchange, bool ifUnused = false) { } - public static void ExchangeDeleteNoWait(this RabbitMQ.Client.IChannel channel, string exchange, bool ifUnused = false) { } - public static void ExchangeUnbind(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask ExchangeUnbindAsync(this RabbitMQ.Client.IChannel channel, string destination, string source, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static void QueueBind(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask QueueBindAsync(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static RabbitMQ.Client.QueueDeclareOk QueueDeclare(this RabbitMQ.Client.IChannel channel, string queue = "", bool durable = false, bool exclusive = true, bool autoDelete = true, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask QueueDeclareAsync(this RabbitMQ.Client.IChannel channel, string queue = "", bool durable = false, bool exclusive = true, bool autoDelete = true, System.Collections.Generic.IDictionary arguments = null) { } - public static uint QueueDelete(this RabbitMQ.Client.IChannel channel, string queue, bool ifUnused = false, bool ifEmpty = false) { } - public static System.Threading.Tasks.ValueTask QueueDeleteAsync(this RabbitMQ.Client.IChannel channel, string queue, bool ifUnused = false, bool ifEmpty = false) { } - public static void QueueDeleteNoWait(this RabbitMQ.Client.IChannel channel, string queue, bool ifUnused = false, bool ifEmpty = false) { } - public static void QueueUnbind(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - public static System.Threading.Tasks.ValueTask QueueUnbindAsync(this RabbitMQ.Client.IChannel channel, string queue, string exchange, string routingKey, System.Collections.Generic.IDictionary arguments = null) { } - } - public interface IConnection : RabbitMQ.Client.INetworkConnection, System.IDisposable - { - ushort ChannelMax { get; } - System.Collections.Generic.IDictionary ClientProperties { get; } - string ClientProvidedName { get; } - RabbitMQ.Client.ShutdownEventArgs CloseReason { get; } - RabbitMQ.Client.AmqpTcpEndpoint Endpoint { get; } - uint FrameMax { get; } - System.TimeSpan Heartbeat { get; } - bool IsOpen { get; } - RabbitMQ.Client.IProtocol Protocol { get; } - System.Collections.Generic.IDictionary ServerProperties { get; } - System.Collections.Generic.IEnumerable ShutdownReport { get; } - event System.EventHandler CallbackException; - event System.EventHandler ConnectionBlocked; - event System.EventHandler ConnectionRecoveryError; - event System.EventHandler ConnectionShutdown; - event System.EventHandler ConnectionUnblocked; - event System.EventHandler ConsumerTagChangeAfterRecovery; - event System.EventHandler QueueNameChangedAfterRecovery; - event System.EventHandler RecoveringConsumer; - event System.EventHandler RecoverySucceeded; - void Close(ushort reasonCode, string reasonText, System.TimeSpan timeout, bool abort); - System.Threading.Tasks.ValueTask CloseAsync(ushort reasonCode, string reasonText, System.TimeSpan timeout, bool abort); - RabbitMQ.Client.IChannel CreateChannel(); - System.Threading.Tasks.ValueTask CreateChannelAsync(); - void UpdateSecret(string newSecret, string reason); - } - public static class IConnectionExtensions - { - public static void Abort(this RabbitMQ.Client.IConnection connection) { } - public static void Abort(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) { } - public static void Abort(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) { } - public static void Abort(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) { } - public static System.Threading.Tasks.ValueTask AbortAsync(this RabbitMQ.Client.IConnection connection) { } - public static System.Threading.Tasks.ValueTask AbortAsync(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) { } - public static System.Threading.Tasks.ValueTask AbortAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) { } - public static System.Threading.Tasks.ValueTask AbortAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) { } - public static void Close(this RabbitMQ.Client.IConnection connection) { } - public static void Close(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) { } - public static void Close(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) { } - public static void Close(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) { } - public static System.Threading.Tasks.ValueTask CloseAsync(this RabbitMQ.Client.IConnection connection) { } - public static System.Threading.Tasks.ValueTask CloseAsync(this RabbitMQ.Client.IConnection connection, System.TimeSpan timeout) { } - public static System.Threading.Tasks.ValueTask CloseAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText) { } - public static System.Threading.Tasks.ValueTask CloseAsync(this RabbitMQ.Client.IConnection connection, ushort reasonCode, string reasonText, System.TimeSpan timeout) { } - } - public interface IConnectionFactory - { - System.Collections.Generic.IDictionary ClientProperties { get; set; } - string ClientProvidedName { get; set; } - int ConsumerDispatchConcurrency { get; set; } - System.TimeSpan ContinuationTimeout { get; set; } - RabbitMQ.Client.ICredentialsProvider CredentialsProvider { get; set; } - RabbitMQ.Client.ICredentialsRefresher CredentialsRefresher { get; set; } - bool DispatchConsumersAsync { get; set; } - System.TimeSpan HandshakeContinuationTimeout { get; set; } - string Password { get; set; } - ushort RequestedChannelMax { get; set; } - uint RequestedFrameMax { get; set; } - System.TimeSpan RequestedHeartbeat { get; set; } - System.Uri Uri { get; set; } - string UserName { get; set; } - string VirtualHost { get; set; } - RabbitMQ.Client.IAuthMechanismFactory AuthMechanismFactory(System.Collections.Generic.IEnumerable mechanismNames); - RabbitMQ.Client.IConnection CreateConnection(); - RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable endpoints); - RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable hostnames); - RabbitMQ.Client.IConnection CreateConnection(string clientProvidedName); - RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName); - RabbitMQ.Client.IConnection CreateConnection(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName); - System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Threading.CancellationToken cancellationToken = default); - System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, System.Threading.CancellationToken cancellationToken = default); - System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, System.Threading.CancellationToken cancellationToken = default); - System.Threading.Tasks.ValueTask CreateConnectionAsync(string clientProvidedName, System.Threading.CancellationToken cancellationToken = default); - System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable endpoints, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default); - System.Threading.Tasks.ValueTask CreateConnectionAsync(System.Collections.Generic.IEnumerable hostnames, string clientProvidedName, System.Threading.CancellationToken cancellationToken = default); - } - public interface ICredentialsProvider - { - string Name { get; } - string Password { get; } - string UserName { get; } - System.TimeSpan? ValidUntil { get; } - void Refresh(); - } - public interface ICredentialsRefresher - { - RabbitMQ.Client.ICredentialsProvider Register(RabbitMQ.Client.ICredentialsProvider provider, RabbitMQ.Client.ICredentialsRefresher.NotifyCredentialRefreshed callback); - bool Unregister(RabbitMQ.Client.ICredentialsProvider provider); - public delegate void NotifyCredentialRefreshed(bool succesfully); - } - public interface IEndpointResolver - { - System.Collections.Generic.IEnumerable All(); - } - public interface INetworkConnection - { - int LocalPort { get; } - int RemotePort { get; } - } - public interface IProtocol - { - string ApiName { get; } - int DefaultPort { get; } - int MajorVersion { get; } - int MinorVersion { get; } - int Revision { get; } - } - public interface IReadOnlyBasicProperties - { - string? AppId { get; } - string? ClusterId { get; } - string? ContentEncoding { get; } - string? ContentType { get; } - string? CorrelationId { get; } - RabbitMQ.Client.DeliveryModes DeliveryMode { get; } - string? Expiration { get; } - System.Collections.Generic.IDictionary? Headers { get; } - string? MessageId { get; } - bool Persistent { get; } - byte Priority { get; } - string? ReplyTo { get; } - RabbitMQ.Client.PublicationAddress? ReplyToAddress { get; } - RabbitMQ.Client.AmqpTimestamp Timestamp { get; } - string? Type { get; } - string? UserId { get; } - bool IsAppIdPresent(); - bool IsClusterIdPresent(); - bool IsContentEncodingPresent(); - bool IsContentTypePresent(); - bool IsCorrelationIdPresent(); - bool IsDeliveryModePresent(); - bool IsExpirationPresent(); - bool IsHeadersPresent(); - bool IsMessageIdPresent(); - bool IsPriorityPresent(); - bool IsReplyToPresent(); - bool IsTimestampPresent(); - bool IsTypePresent(); - bool IsUserIdPresent(); - } - public interface IRecordedBinding - { - System.Collections.Generic.IDictionary? Arguments { get; } - string Destination { get; } - string RoutingKey { get; } - string Source { get; } - } - public interface IRecordedConsumer - { - System.Collections.Generic.IDictionary? Arguments { get; } - bool AutoAck { get; } - string ConsumerTag { get; } - bool Exclusive { get; } - string Queue { get; } - } - public interface IRecordedExchange - { - System.Collections.Generic.IDictionary? Arguments { get; } - bool AutoDelete { get; } - bool Durable { get; } - string Name { get; } - string Type { get; } - } - public interface IRecordedQueue - { - System.Collections.Generic.IDictionary? Arguments { get; } - bool AutoDelete { get; } - bool Durable { get; } - bool Exclusive { get; } - bool IsServerNamed { get; } - string Name { get; } - } - public interface IRecoverable - { - event System.EventHandler Recovery; - } - public interface ITcpClient : System.IDisposable - { - System.Net.Sockets.Socket Client { get; } - bool Connected { get; } - System.TimeSpan ReceiveTimeout { get; set; } - void Close(); - System.Threading.Tasks.Task ConnectAsync(System.Net.IPAddress host, int port, System.Threading.CancellationToken cancellationToken = default); - System.Net.Sockets.NetworkStream GetStream(); - } - public class PlainMechanism : RabbitMQ.Client.IAuthMechanism - { - public PlainMechanism() { } - public byte[] handleChallenge(byte[] challenge, RabbitMQ.Client.ConnectionConfig config) { } - } - public class PlainMechanismFactory : RabbitMQ.Client.IAuthMechanismFactory - { - public PlainMechanismFactory() { } - public string Name { get; } - public RabbitMQ.Client.IAuthMechanism GetInstance() { } - } - public static class Protocols - { - public static readonly RabbitMQ.Client.IProtocol AMQP_0_9_1; - public static readonly RabbitMQ.Client.IProtocol DefaultProtocol; - } - public class PublicationAddress - { - public readonly string ExchangeName; - public readonly string ExchangeType; - public readonly string RoutingKey; - public static readonly System.Text.RegularExpressions.Regex PSEUDO_URI_PARSER; - public PublicationAddress(string exchangeType, string exchangeName, string routingKey) { } - public override string ToString() { } - public static RabbitMQ.Client.PublicationAddress Parse(string uriLikeString) { } - public static bool TryParse(string uriLikeString, out RabbitMQ.Client.PublicationAddress result) { } - } - public class QueueDeclareOk - { - public readonly uint ConsumerCount; - public readonly uint MessageCount; - public readonly string QueueName; - public QueueDeclareOk(string queueName, uint messageCount, uint consumerCount) { } - public static string op_Implicit(RabbitMQ.Client.QueueDeclareOk declareOk) { } - } - public readonly struct ReadOnlyBasicProperties : RabbitMQ.Client.IReadOnlyBasicProperties - { - public ReadOnlyBasicProperties(System.ReadOnlySpan span) { } - public string? AppId { get; } - public string? ClusterId { get; } - public string? ContentEncoding { get; } - public string? ContentType { get; } - public string? CorrelationId { get; } - public RabbitMQ.Client.DeliveryModes DeliveryMode { get; } - public string? Expiration { get; } - public System.Collections.Generic.IDictionary? Headers { get; } - public string? MessageId { get; } - public bool Persistent { get; } - public byte Priority { get; } - public string? ReplyTo { get; } - public RabbitMQ.Client.PublicationAddress? ReplyToAddress { get; } - public RabbitMQ.Client.AmqpTimestamp Timestamp { get; } - public string? Type { get; } - public string? UserId { get; } - public bool IsAppIdPresent() { } - public bool IsClusterIdPresent() { } - public bool IsContentEncodingPresent() { } - public bool IsContentTypePresent() { } - public bool IsCorrelationIdPresent() { } - public bool IsDeliveryModePresent() { } - public bool IsExpirationPresent() { } - public bool IsHeadersPresent() { } - public bool IsMessageIdPresent() { } - public bool IsPriorityPresent() { } - public bool IsReplyToPresent() { } - public bool IsTimestampPresent() { } - public bool IsTypePresent() { } - public bool IsUserIdPresent() { } - } - public class ShutdownEventArgs : System.EventArgs - { - public ShutdownEventArgs(RabbitMQ.Client.ShutdownInitiator initiator, ushort replyCode, string replyText, System.Exception exception) { } - public ShutdownEventArgs(RabbitMQ.Client.ShutdownInitiator initiator, ushort replyCode, string replyText, object cause = null) { } - public ShutdownEventArgs(RabbitMQ.Client.ShutdownInitiator initiator, ushort replyCode, string replyText, ushort classId, ushort methodId, object cause = null) { } - public object Cause { get; } - public ushort ClassId { get; } - public System.Exception Exception { get; } - public RabbitMQ.Client.ShutdownInitiator Initiator { get; } - public ushort MethodId { get; } - public ushort ReplyCode { get; } - public string ReplyText { get; } - public override string ToString() { } - } - public enum ShutdownInitiator - { - Application = 0, - Library = 1, - Peer = 2, - } - public class ShutdownReportEntry - { - public ShutdownReportEntry(string description, System.Exception exception) { } - public string Description { get; set; } - public System.Exception Exception { get; set; } - public override string ToString() { } - } - public class SslOption - { - public SslOption() { } - public SslOption(string serverName, string certificatePath = "", bool enabled = false) { } - public System.Net.Security.SslPolicyErrors AcceptablePolicyErrors { get; set; } - public string CertPassphrase { get; set; } - public string CertPath { get; set; } - public System.Net.Security.LocalCertificateSelectionCallback CertificateSelectionCallback { get; set; } - public System.Net.Security.RemoteCertificateValidationCallback CertificateValidationCallback { get; set; } - public System.Security.Cryptography.X509Certificates.X509CertificateCollection Certs { get; set; } - public bool CheckCertificateRevocation { get; set; } - public bool Enabled { get; set; } - public string ServerName { get; set; } - public System.Security.Authentication.SslProtocols Version { get; set; } - } - public class TcpClientAdapter : RabbitMQ.Client.ITcpClient, System.IDisposable - { - public TcpClientAdapter(System.Net.Sockets.Socket socket) { } - public virtual System.Net.Sockets.Socket Client { get; } - public virtual bool Connected { get; } - public virtual System.TimeSpan ReceiveTimeout { get; set; } - public virtual void Close() { } - public virtual System.Threading.Tasks.Task ConnectAsync(System.Net.IPAddress ep, int port, System.Threading.CancellationToken cancellationToken = default) { } - public void Dispose() { } - protected virtual void Dispose(bool disposing) { } - public virtual System.Net.Sockets.NetworkStream GetStream() { } - public static System.Net.IPAddress GetMatchingHost(System.Collections.Generic.IReadOnlyCollection addresses, System.Net.Sockets.AddressFamily addressFamily) { } - } - public class TimerBasedCredentialRefresher : RabbitMQ.Client.ICredentialsRefresher - { - public TimerBasedCredentialRefresher() { } - public RabbitMQ.Client.ICredentialsProvider Register(RabbitMQ.Client.ICredentialsProvider provider, RabbitMQ.Client.ICredentialsRefresher.NotifyCredentialRefreshed callback) { } - public bool Unregister(RabbitMQ.Client.ICredentialsProvider provider) { } - } - [System.Diagnostics.Tracing.EventSource(Name="TimerBasedCredentialRefresher")] - public class TimerBasedCredentialRefresherEventSource : System.Diagnostics.Tracing.EventSource - { - public TimerBasedCredentialRefresherEventSource() { } - public static RabbitMQ.Client.TimerBasedCredentialRefresherEventSource Log { get; } - [System.Diagnostics.Tracing.Event(6)] - public void AlreadyRegistered(string name) { } - [System.Diagnostics.Tracing.Event(5)] - public void RefreshedCredentials(string name, bool succesfully) { } - [System.Diagnostics.Tracing.Event(1)] - public void Registered(string name) { } - [System.Diagnostics.Tracing.Event(3)] - public void ScheduledTimer(string name, double interval) { } - [System.Diagnostics.Tracing.Event(4)] - public void TriggeredTimer(string name) { } - [System.Diagnostics.Tracing.Event(2)] - public void Unregistered(string name) { } - } - public class TopologyRecoveryExceptionHandler - { - public TopologyRecoveryExceptionHandler() { } - public System.Func BindingRecoveryExceptionCondition { get; set; } - public System.Action BindingRecoveryExceptionHandler { get; set; } - public System.Func ConsumerRecoveryExceptionCondition { get; set; } - public System.Action ConsumerRecoveryExceptionHandler { get; set; } - public System.Func ExchangeRecoveryExceptionCondition { get; set; } - public System.Action ExchangeRecoveryExceptionHandler { get; set; } - public System.Func QueueRecoveryExceptionCondition { get; set; } - public System.Action QueueRecoveryExceptionHandler { get; set; } - } - public class TopologyRecoveryFilter - { - public TopologyRecoveryFilter() { } - public System.Func BindingFilter { get; set; } - public System.Func ConsumerFilter { get; set; } - public System.Func ExchangeFilter { get; set; } - public System.Func QueueFilter { get; set; } - } -} -namespace RabbitMQ.Client.Events -{ - public delegate System.Threading.Tasks.Task AsyncEventHandler(object sender, TEvent @event); - public class AsyncEventingBasicConsumer : RabbitMQ.Client.AsyncDefaultBasicConsumer - { - public AsyncEventingBasicConsumer(RabbitMQ.Client.IChannel channel) { } - public event RabbitMQ.Client.Events.AsyncEventHandler Received; - public event RabbitMQ.Client.Events.AsyncEventHandler Registered; - public event RabbitMQ.Client.Events.AsyncEventHandler Shutdown; - public event RabbitMQ.Client.Events.AsyncEventHandler Unregistered; - public override System.Threading.Tasks.Task HandleBasicCancelOk(string consumerTag) { } - public override System.Threading.Tasks.Task HandleBasicConsumeOk(string consumerTag) { } - public override System.Threading.Tasks.Task HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) { } - public override System.Threading.Tasks.Task HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) { } - } - public abstract class BaseExceptionEventArgs : System.EventArgs - { - public readonly System.Collections.Generic.IDictionary Detail; - public readonly System.Exception Exception; - protected BaseExceptionEventArgs(System.Collections.Generic.IDictionary detail, System.Exception exception) { } - } - public class BasicAckEventArgs : System.EventArgs - { - public readonly ulong DeliveryTag; - public readonly bool Multiple; - public BasicAckEventArgs(ulong deliveryTag, bool multiple) { } - } - public class BasicDeliverEventArgs : System.EventArgs - { - public readonly RabbitMQ.Client.ReadOnlyBasicProperties BasicProperties; - public readonly System.ReadOnlyMemory Body; - public readonly string ConsumerTag; - public readonly ulong DeliveryTag; - public readonly string Exchange; - public readonly bool Redelivered; - public readonly string RoutingKey; - public BasicDeliverEventArgs(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) { } - } - public class BasicNackEventArgs : System.EventArgs - { - public readonly ulong DeliveryTag; - public readonly bool Multiple; - public readonly bool Requeue; - public BasicNackEventArgs(ulong deliveryTag, bool multiple, bool requeue) { } - } - public class BasicReturnEventArgs : System.EventArgs - { - public readonly RabbitMQ.Client.ReadOnlyBasicProperties BasicProperties; - public readonly System.ReadOnlyMemory Body; - public readonly string Exchange; - public readonly ushort ReplyCode; - public readonly string ReplyText; - public readonly string RoutingKey; - public BasicReturnEventArgs(ushort replyCode, string replyText, string exchange, string routingKey, RabbitMQ.Client.ReadOnlyBasicProperties basicProperties, System.ReadOnlyMemory body) { } - } - public class CallbackExceptionEventArgs : RabbitMQ.Client.Events.BaseExceptionEventArgs - { - public CallbackExceptionEventArgs(System.Collections.Generic.IDictionary detail, System.Exception exception) { } - public static RabbitMQ.Client.Events.CallbackExceptionEventArgs Build(System.Exception e, string context) { } - public static RabbitMQ.Client.Events.CallbackExceptionEventArgs Build(System.Exception e, string context, object consumer) { } - } - public class ConnectionBlockedEventArgs : System.EventArgs - { - public readonly string Reason; - public ConnectionBlockedEventArgs(string reason) { } - } - public sealed class ConnectionRecoveryErrorEventArgs : System.EventArgs - { - public readonly System.Exception Exception; - public ConnectionRecoveryErrorEventArgs(System.Exception ex) { } - } - public class ConsumerEventArgs : System.EventArgs - { - public readonly string[] ConsumerTags; - public ConsumerEventArgs(string[] consumerTags) { } - } - public sealed class ConsumerTagChangedAfterRecoveryEventArgs : System.EventArgs - { - public readonly string TagAfter; - public readonly string TagBefore; - public ConsumerTagChangedAfterRecoveryEventArgs(string tagBefore, string tagAfter) { } - } - public class EventingBasicConsumer : RabbitMQ.Client.DefaultBasicConsumer - { - public EventingBasicConsumer(RabbitMQ.Client.IChannel channel) { } - public event System.EventHandler Received; - public event System.EventHandler Registered; - public event System.EventHandler Shutdown; - public event System.EventHandler Unregistered; - public override void HandleBasicCancelOk(string consumerTag) { } - public override void HandleBasicConsumeOk(string consumerTag) { } - public override void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redelivered, string exchange, string routingKey, in RabbitMQ.Client.ReadOnlyBasicProperties properties, System.ReadOnlyMemory body) { } - public override void HandleChannelShutdown(object channel, RabbitMQ.Client.ShutdownEventArgs reason) { } - } - public class FlowControlEventArgs : System.EventArgs - { - public readonly bool Active; - public FlowControlEventArgs(bool active) { } - } - public sealed class QueueNameChangedAfterRecoveryEventArgs : System.EventArgs - { - public readonly string NameAfter; - public readonly string NameBefore; - public QueueNameChangedAfterRecoveryEventArgs(string nameBefore, string nameAfter) { } - } - public class RecoveringConsumerEventArgs - { - public RecoveringConsumerEventArgs(string consumerTag, System.Collections.Generic.IDictionary consumerArguments) { } - public System.Collections.Generic.IDictionary ConsumerArguments { get; } - public string ConsumerTag { get; } - } -} -namespace RabbitMQ.Client.Exceptions -{ - [System.Serializable] - public class AlreadyClosedException : RabbitMQ.Client.Exceptions.OperationInterruptedException - { - public AlreadyClosedException(RabbitMQ.Client.ShutdownEventArgs reason) { } - } - [System.Serializable] - public class AuthenticationFailureException : RabbitMQ.Client.Exceptions.PossibleAuthenticationFailureException - { - public AuthenticationFailureException(string msg) { } - } - [System.Serializable] - public class BrokerUnreachableException : System.IO.IOException - { - public BrokerUnreachableException(System.Exception Inner) { } - } - [System.Serializable] - public class ChannelAllocationException : RabbitMQ.Client.Exceptions.ProtocolViolationException - { - public ChannelAllocationException() { } - public ChannelAllocationException(int channel) { } - public int Channel { get; } - } - [System.Serializable] - public class ConnectFailureException : RabbitMQ.Client.Exceptions.ProtocolViolationException - { - public ConnectFailureException(string msg, System.Exception inner) { } - } - public abstract class HardProtocolException : RabbitMQ.Client.Exceptions.ProtocolException - { - protected readonly bool _canShutdownCleanly; - protected HardProtocolException(string message) { } - protected HardProtocolException(string message, bool canShutdownCleanly) { } - public bool CanShutdownCleanly { get; } - } - public class MalformedFrameException : RabbitMQ.Client.Exceptions.HardProtocolException - { - public MalformedFrameException(string message) { } - public MalformedFrameException(string message, bool canShutdownCleanly) { } - public override ushort ReplyCode { get; } - } - [System.Serializable] - public class OperationInterruptedException : RabbitMQ.Client.Exceptions.RabbitMQClientException - { - protected OperationInterruptedException() { } - public OperationInterruptedException(RabbitMQ.Client.ShutdownEventArgs reason) { } - protected OperationInterruptedException(string message) { } - public OperationInterruptedException(RabbitMQ.Client.ShutdownEventArgs reason, string prefix) { } - protected OperationInterruptedException(string message, System.Exception inner) { } - public RabbitMQ.Client.ShutdownEventArgs ShutdownReason { get; set; } - } - [System.Serializable] - public class PacketNotRecognizedException : RabbitMQ.Client.Exceptions.RabbitMQClientException - { - public PacketNotRecognizedException(int transportHigh, int transportLow, int serverMajor, int serverMinor) { } - public int ServerMajor { get; } - public int ServerMinor { get; } - public int TransportHigh { get; } - public int TransportLow { get; } - } - [System.Serializable] - public class PossibleAuthenticationFailureException : RabbitMQ.Client.Exceptions.RabbitMQClientException - { - public PossibleAuthenticationFailureException(string msg) { } - public PossibleAuthenticationFailureException(string msg, System.Exception inner) { } - } - public abstract class ProtocolException : RabbitMQ.Client.Exceptions.RabbitMQClientException - { - protected ProtocolException(string message) { } - public abstract ushort ReplyCode { get; } - public virtual RabbitMQ.Client.ShutdownEventArgs ShutdownReason { get; } - } - [System.Serializable] - public class ProtocolVersionMismatchException : RabbitMQ.Client.Exceptions.ProtocolViolationException - { - public ProtocolVersionMismatchException(int clientMajor, int clientMinor, int serverMajor, int serverMinor) { } - public int ClientMajor { get; } - public int ClientMinor { get; } - public int ServerMajor { get; } - public int ServerMinor { get; } - } - [System.Serializable] - public class ProtocolViolationException : RabbitMQ.Client.Exceptions.RabbitMQClientException - { - public ProtocolViolationException() { } - public ProtocolViolationException(string message) { } - public ProtocolViolationException(string message, System.Exception inner) { } - } - [System.Serializable] - public abstract class RabbitMQClientException : System.Exception - { - protected RabbitMQClientException() { } - protected RabbitMQClientException(string message) { } - protected RabbitMQClientException(string message, System.Exception innerException) { } - } - public class SyntaxErrorException : RabbitMQ.Client.Exceptions.HardProtocolException - { - public SyntaxErrorException(string message) { } - public override ushort ReplyCode { get; } - } - public class TopologyRecoveryException : RabbitMQ.Client.Exceptions.RabbitMQClientException - { - public TopologyRecoveryException(string message, System.Exception cause) { } - } - public class UnexpectedFrameException : RabbitMQ.Client.Exceptions.HardProtocolException - { - public override ushort ReplyCode { get; } - } - [System.Serializable] - public class UnexpectedMethodException : RabbitMQ.Client.Exceptions.ProtocolViolationException - { - public ushort ExpectedProtocolClassId { get; } - public ushort ExpectedProtocolMethodId { get; } - public string ExpectedProtocolMethodName { get; } - public ushort ProtocolClassId { get; } - public ushort ProtocolMethodId { get; } - public string ProtocolMethodName { get; } - } - public class UnknownClassOrMethodException : RabbitMQ.Client.Exceptions.HardProtocolException - { - public UnknownClassOrMethodException(ushort classId, ushort methodId) { } - public ushort ClassId { get; } - public ushort MethodId { get; } - public override ushort ReplyCode { get; } - public override string ToString() { } - } - [System.Serializable] - public class WireFormattingException : RabbitMQ.Client.Exceptions.ProtocolViolationException - { - public WireFormattingException(string message) { } - public WireFormattingException(string message, object offender) { } - public object Offender { get; } - } -} -namespace RabbitMQ.Client.Logging -{ - [System.Diagnostics.Tracing.EventData] - public class RabbitMqExceptionDetail - { - public RabbitMqExceptionDetail(System.Collections.Generic.IDictionary ex) { } - public RabbitMqExceptionDetail(System.Exception ex) { } - public string InnerException { get; } - public string Message { get; } - public string StackTrace { get; } - public string Type { get; } - public override string ToString() { } - } -} \ No newline at end of file diff --git a/projects/Test/Unit/APIApproval.cs b/projects/Test/Unit/APIApproval.cs deleted file mode 100644 index 8ce97b5c34..0000000000 --- a/projects/Test/Unit/APIApproval.cs +++ /dev/null @@ -1,63 +0,0 @@ -// This source code is dual-licensed under the Apache License, version -// 2.0, and the Mozilla Public License, version 2.0. -// -// The APL v2.0: -// -//--------------------------------------------------------------------------- -// Copyright (c) 2007-2020 VMware, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// https://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. -//--------------------------------------------------------------------------- -// -// The MPL v2.0: -// -//--------------------------------------------------------------------------- -// This Source Code Form is subject to the terms of the Mozilla Public -// License, v. 2.0. If a copy of the MPL was not distributed with this -// file, You can obtain one at https://mozilla.org/MPL/2.0/. -// -// Copyright (c) 2007-2020 VMware, Inc. All rights reserved. -//--------------------------------------------------------------------------- - -using System; -using System.Threading.Tasks; -using PublicApiGenerator; -using VerifyTests; -using VerifyXunit; -using Xunit; - -namespace Test.Unit -{ - [UsesVerify] - public class APIApproval - { - private static readonly ApiGeneratorOptions opts = new ApiGeneratorOptions - { - ExcludeAttributes = new[] - { - "System.Runtime.Versioning.TargetFrameworkAttribute", - "System.Reflection.AssemblyMetadataAttribute" - } - }; - - [Fact] - public Task Approve() - { - Type apiType = typeof(RabbitMQ.Client.ConnectionFactory); - string publicApi = apiType.Assembly.GeneratePublicApi(opts); - var settings = new VerifySettings(); - settings.DisableDiff(); - return Verifier.Verify(publicApi, settings); - } - } -} diff --git a/projects/Test/Unit/Unit.csproj b/projects/Test/Unit/Unit.csproj index 85fb9574fe..7abcf04af3 100644 --- a/projects/Test/Unit/Unit.csproj +++ b/projects/Test/Unit/Unit.csproj @@ -22,17 +22,9 @@ - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - + - - runtime; build; native; contentfiles; analyzers; buildtransitive - all - - +