NegotiateStream.Write(Byte[], Int32, Int32) Método

Definição

Espaço de Nomes:
System.Net.Security
Assemblagem:
System.dll
Assemblagem:
netstandard.dll

Escreva o número especificado de Bytes no fluxo subjacente usando o buffer e o deslocamento especificados.

public:
 override void Write(cli::array <System::Byte> ^ buffer, int offset, int count);
public override void Write(byte[] buffer, int offset, int count);
override this.Write : byte[] * int * int -> unit
Public Overrides Sub Write (buffer As Byte(), offset As Integer, count As Integer)

Parâmetros

buffer
Byte[]

Um Byte array que fornece os bytes escritos no fluxo.

offset
Int32

E contendo Int32 a localização baseada em zero em buffer onde começar a ler bytes a serem escritos no fluxo.

count
Int32

A Int32 contendo o número de bytes a ler de buffer.

Exceções

ArgumentNullException

buffer é null.

ArgumentException

offset é inferior a 0.

-ou-

offset é maior do que o comprimento de buffer.

-ou-

offset mais contagem é maior do que o comprimento de buffer.

IOException

A operação de escrita falhou.

-ou-

A encriptação está em uso, mas os dados não puderam ser encriptados.

NotSupportedException

Já está em curso uma operação de escrita.

ObjectDisposedException

Este objeto foi encerrado.

InvalidOperationException

A autenticação não ocorreu.

Exemplos

O seguinte exemplo de código demonstra a escrita para um NegotiateStream.

    public static void Main(String[] args)
    {
        // Establish the remote endpoint for the socket.
        // For this example, use the local machine.
        IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
        IPAddress ipAddress = ipHostInfo.AddressList[0];
        // Client and server use port 11000.
        IPEndPoint remoteEP = new IPEndPoint(ipAddress,11000);
        // Create a TCP/IP socket.
       TcpClient client = new TcpClient();
        // Connect the socket to the remote endpoint.
        client.Connect(remoteEP);
        Console.WriteLine("Client connected to {0}.",
            remoteEP.ToString());
        // Ensure the client does not close when there is
        // still data to be sent to the server.
        client.LingerState = (new LingerOption(true,0));
        // Request authentication.
        NetworkStream clientStream = client.GetStream();
        NegotiateStream authStream = new NegotiateStream(clientStream);
        // Request authentication for the client only (no mutual authentication).
        // Authenicate using the client's default credetials.
        // Permit the server to impersonate the client to access resources on the server only.
        // Request that data be transmitted using encryption and data signing.
        authStream.AuthenticateAsClient(
             (NetworkCredential) CredentialCache.DefaultCredentials,
             "",
             ProtectionLevel.EncryptAndSign,
             TokenImpersonationLevel.Impersonation);
        DisplayAuthenticationProperties(authStream);
        DisplayStreamProperties(authStream);
        if (authStream.CanWrite)
        {
             // Encode the test data into a byte array.
            byte[] message = System.Text.Encoding.UTF8.GetBytes("Hello from the client.");
            authStream.Write(message, 0, message.Length);
            authStream.Flush();
            Console.WriteLine("Sent {0} bytes.", message.Length);
        }
        // Close the client connection.
        authStream.Close();
        Console.WriteLine("Client closed.");
}

Observações

Se a encriptação, assinatura ou encriptação e assinatura estiverem ativados, este método lê os dados do buffer, encripta, assina ou encripta-os e assina-os, e transmite-os usando o fluxo subjacente. Se não estiverem em uso serviços de segurança como encriptação ou assinatura de dados, este método invoca Write o fluxo subjacente.

Este método bloqueia enquanto a operação de escrita termina. Para evitar bloqueios enquanto a operação termina, utilize o WriteAsync método.

Não pode chamar este método até ter autenticado com sucesso. Para autenticar, chame um dos AuthenticateAsClient, AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsync, ou BeginAuthenticateAsServer métodos.

A NegotiateStream classe não suporta múltiplas operações de escrita simultâneas. Se tentar iniciar uma operação de escrita enquanto outra já está a ser executada no mesmo fluxo, será lançada uma NotSupportedException exceção.

Aplica-se a