SslApplicationProtocol Estrutura

Referência

Definição

Namespace:: System.Net.Security

Assemblies:: netstandard.dll, System.Net.Security.dll

Assembly:: System.Net.Security.dll

Assembly:: netstandard.dll

Origem:: SslApplicationProtocol.cs

Origem:: SslApplicationProtocol.cs

Origem:: SslApplicationProtocol.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Representa um valor do protocolo de aplicativo TLS.

public value class SslApplicationProtocol : IEquatable<System::Net::Security::SslApplicationProtocol>

public readonly struct SslApplicationProtocol : IEquatable<System.Net.Security.SslApplicationProtocol>

type SslApplicationProtocol = struct

Public Structure SslApplicationProtocol
Implements IEquatable(Of SslApplicationProtocol)

Herança: Object

ValueType
SslApplicationProtocol

Implementações: IEquatable<SslApplicationProtocol>

Exemplos

O exemplo de código a seguir demonstra a negociação do protocolo no nível do aplicativo em SslStream. O servidor anuncia o suporte para protocol1 e protocol2. O cliente anuncia o suporte para protocol2 e protocol3. O protocolo comumente compatível (protocol2) é negociado durante o handshake.

async Task Server(NetworkStream stream, X509Certificate2 serverCertificate)
{
    using var server = new SslStream(stream);

    await server.AuthenticateAsServerAsync(new SslServerAuthenticationOptions
    {
        ServerCertificate = serverCertificate,
        ApplicationProtocols = new()
        {
            new("protocol1"),
            new("protocol2"),
        }
    });

    string protocol = Encoding.ASCII.GetString(server.NegotiatedApplicationProtocol.Protocol.Span);
    System.Console.WriteLine($"Server - negotiated protocol: {protocol}");
}

async Task Client(NetworkStream stream, string hostName)
{
    using var client = new SslStream(stream);

    await client.AuthenticateAsClientAsync(new SslClientAuthenticationOptions
    {
        // the host name must match the name on the certificate used on the server side
        TargetHost = hostName,
        ApplicationProtocols = new()
        {
            new("protocol2"),
            new("protocol3")
        }
    });

    string protocol = Encoding.ASCII.GetString(client.NegotiatedApplicationProtocol.Protocol.Span);
    System.Console.WriteLine($"Client - negotiated protocol: {protocol}");
}

// possible output:
//   Server - negotiated protocol: protocol2
//   Client - negotiated protocol: protocol2

Async Function Server(stream As NetworkStream, serverCertificate As X509Certificate2) As Task
    Using serverStream As SslStream = new SslStream(stream)
        Dim options as New SslServerAuthenticationOptions() With
        {
            .ServerCertificate = serverCertificate,
            .ApplicationProtocols = New List(Of SslApplicationProtocol) From
            {
                New SslApplicationProtocol("protocol1"),
                New SslApplicationProtocol("protocol2")
            }
        }
        Await serverStream.AuthenticateAsServerAsync(options)

        Dim protocol As String = Encoding.ASCII.GetString(
            serverStream.NegotiatedApplicationProtocol.Protocol.Span)
        System.Console.WriteLine($"Server - negotiated protocol: {protocol}")
    End Using
End Function

Async Function Client(stream As NetworkStream, hostName As String ) As Task
    Using clientStream As SslStream = new SslStream(stream)
        Dim options as New SslClientAuthenticationOptions() With
        {
            .TargetHost = hostName,
            .ApplicationProtocols = New List(Of SslApplicationProtocol) From
            {
                New SslApplicationProtocol("protocol2"),
                New SslApplicationProtocol("protocol3")
            }
        }
        Await clientStream.AuthenticateAsClientAsync(options)

        Dim protocol As String = Encoding.ASCII.GetString(
            clientStream.NegotiatedApplicationProtocol.Protocol.Span)
        System.Console.WriteLine($"Client - negotiated protocol: {protocol}")
    End Using
End Function

' possible output:
'   Server - negotiated protocol: protocol2
'   Client - negotiated protocol: protocol2

Comentários

Esse tipo contém campos estáticos com valores predefinidos SslApplicationProtocol para versões HTTP.

Durante o handshake, o cliente envia uma lista de protocolos ALPN disponíveis e o servidor escolhe a melhor correspondência nessa lista.

Para obter uma lista completa de protocolos com suporte, consulte IDs de protocolo ALPN (Negociação de Protocolo Application-Layer TLS).

Construtores

SslApplicationProtocol(Byte[])	Inicializa uma nova instância do SslApplicationProtocol.
SslApplicationProtocol(String)	Inicializa uma nova instância do SslApplicationProtocol.

Campos

Http11	Obtém um SslApplicationProtocol representando o protocolo de aplicativo TLS HTTP/1.1.
Http2	Obtém um SslApplicationProtocol representando o protocolo de aplicativo TLS HTTP/2.
Http3	Define uma SslApplicationProtocol instância para HTTP 3.0.

Propriedades

Protocol

Obtém um protocolo de aplicativo TLS atual representado por este SslApplicationProtocol.

Métodos

Equals(Object)	Compara o SslApplicationProtocol ao objeto especificado.
Equals(SslApplicationProtocol)	Compara um SslApplicationProtocol à instância SslApplicationProtocol especificada.
GetHashCode()	Retorna o código hash da instância de SslApplicationProtocol.
ToString()	Substitui o método ToString().

Operadores

Equality(SslApplicationProtocol, SslApplicationProtocol)	O operador de igualdade para comparar dois objetos SslApplicationProtocol.
Inequality(SslApplicationProtocol, SslApplicationProtocol)	Operador de desigualdade para comparar dois objetos SslApplicationProtocol.

Aplica-se a

Produto	Versões
.NET	Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Standard	2.1

Compartilhar via