NegotiateStream.Write(Byte[], Int32, Int32) Metod

Definition

Namnområde:
System.Net.Security
Sammansättning:
System.dll
Sammansättning:
netstandard.dll

Skriv det angivna antalet Bytes till den underliggande strömmen med den angivna bufferten och förskjutningen.

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)

Parametrar

buffer
Byte[]

En Byte matris som tillhandahåller byte som skrivits till strömmen.

offset
Int32

En Int32 som innehåller den nollbaserade plats buffer där byte som ska skrivas till strömmen ska börja läsas.

count
Int32

A Int32 som innehåller antalet byte som ska läsas från buffer.

Undantag

ArgumentNullException

buffer är null.

ArgumentException

offset är mindre än 0.

-eller-

offset är större än längden på buffer.

-eller-

offset plusantalet är större än längden på buffer.

IOException

Skrivåtgärden misslyckades.

-eller-

Kryptering används, men det gick inte att kryptera data.

NotSupportedException

Det pågår redan en skrivåtgärd.

ObjectDisposedException

Det här objektet har stängts.

InvalidOperationException

Autentiseringen har inte inträffat.

Exempel

Följande kodexempel visar hur du skriver till en 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.");
}

Kommentarer

Om kryptering, signering eller kryptering och signering är aktiverade läser den här metoden data från buffert, krypterar, signerar eller krypterar och signerar dem och överför dem med hjälp av den underliggande strömmen. Om inga säkerhetstjänster som datakryptering eller signering används anropas Write den här metoden på den underliggande strömmen.

Den här metoden blockerar medan skrivåtgärden slutförs. Om du vill förhindra blockering när åtgärden är klar använder du WriteAsync metoden .

Du kan inte anropa den här metoden förrän du har autentiserats. Om du vill autentisera AuthenticateAsClientanropar du någon av metoderna , AuthenticateAsClientAsync, BeginAuthenticateAsClient, AuthenticateAsServer, AuthenticateAsServerAsynceller BeginAuthenticateAsServer .

Klassen NegotiateStream stöder inte flera samtidiga skrivåtgärder. Om du försöker starta en skrivåtgärd medan en annan skrivåtgärd redan körs på samma ström genereras ett NotSupportedException undantag.

Gäller för