NegotiateStream Třída

Definice

Obor názvů:

System.Net.Security

Sestavení:

netstandard.dll, System.Net.Security.dll

Zdroj:

NegotiateStream.cs

Poskytuje datový proud, který používá protokol zabezpečení Negotiate k ověření klienta a volitelně i serveru při komunikaci mezi klientem a serverem.

public ref class NegotiateStream : System::Net::Security::AuthenticatedStream

public class NegotiateStream : System.Net.Security.AuthenticatedStream

type NegotiateStream = class
    inherit AuthenticatedStream

Public Class NegotiateStream
Inherits AuthenticatedStream

Dědičnost

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Příklady

Následující příklad ukazuje straně klienta připojení klient-server, který používá NegotiateStream. Klient se ověří a odešle zprávu na server asynchronně.

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Text;

namespace Examples.NegotiateStreamExample
{
    public class ASynchronousAuthenticatingTcpClient
    {
        static TcpClient client = null;

        public static void Main(String[] args)
        {
            // Establish the remote endpoint for the socket.
            // For this example, use the local machine.
            IPHostEntry ipHostInfo = Dns.GetHostEntry("localhost");
            IPAddress ipAddress = ipHostInfo.AddressList[0];
            // Client and server use port 11000.
            IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);
            // Create a TCP/IP socket.
            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, false);
            // Pass the NegotiateStream as the AsyncState object
            // so that it is available to the callback delegate.
            Task authenticateTask = authStream
                .AuthenticateAsClientAsync()
                .ContinueWith(task =>
                {
                    Console.WriteLine("Client ending authentication...");
                    Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);
                });

            Console.WriteLine("Client waiting for authentication...");
            // Wait until the result is available.
            authenticateTask.Wait();
            // Display the properties of the authenticated stream.
            AuthenticatedStreamReporter.DisplayProperties(authStream);
            // Send a message to the server.
            // Encode the test data into a byte array.
            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
            Task writeTask = authStream
                .WriteAsync(message, 0, message.Length)
                .ContinueWith(task =>
                {
                    Console.WriteLine("Client ending write operation...");
                });

            writeTask.Wait();
            Console.WriteLine("Sent {0} bytes.", message.Length);
            // Close the client connection.
            authStream.Close();
            Console.WriteLine("Client closed.");
        }
    }

    // The following class displays the properties of an authenticatedStream.
    public class AuthenticatedStreamReporter
    {
        public static void DisplayProperties(AuthenticatedStream stream)
        {
            Console.WriteLine("IsAuthenticated: {0}", stream.IsAuthenticated);
            Console.WriteLine("IsMutuallyAuthenticated: {0}", stream.IsMutuallyAuthenticated);
            Console.WriteLine("IsEncrypted: {0}", stream.IsEncrypted);
            Console.WriteLine("IsSigned: {0}", stream.IsSigned);
            Console.WriteLine("IsServer: {0}", stream.IsServer);
        }
    }
}

Imports System.Text
Imports System.Net.Sockets
Imports System.Net.Security
Imports System.Net

Namespace Examples.NegotiateStreamExample

    Public Class ASynchronousAuthenticatingTcpClient

        Shared client As TcpClient = Nothing

        Public Shared Sub Main(args As String())
            ' Establish the remote endpoint for the socket.
            ' For this example, use the local machine.
            Dim ipHostInfo = Dns.GetHostEntry("localhost")
            Dim ipAddress = ipHostInfo.AddressList(0)

            ' Client and server use port 11000. 
            Dim remoteEP As New IPEndPoint(ipAddress, 11000)

            ' Create a TCP/IP socket.
            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.
            Dim clientStream = client.GetStream()
            Dim authStream As New NegotiateStream(clientStream, False)

            ' Pass the NegotiateStream as the AsyncState object 
            ' so that it is available to the callback delegate.
            Dim ar = authStream.BeginAuthenticateAsClient(
                New AsyncCallback(AddressOf EndAuthenticateCallback), authStream)

            Console.WriteLine("Client waiting for authentication...")

            ' Wait until the result is available.
            ar.AsyncWaitHandle.WaitOne()

            ' Display the properties of the authenticated stream.
            AuthenticatedStreamReporter.DisplayProperties(authStream)

            ' Send a message to the server.
            ' Encode the test data into a byte array.
            Dim message = Encoding.UTF8.GetBytes("Hello from the client.")
            ar = authStream.BeginWrite(message, 0, message.Length, 
                New AsyncCallback(AddressOf EndWriteCallback), authStream)
            ar.AsyncWaitHandle.WaitOne()
            Console.WriteLine("Sent {0} bytes.", message.Length)

            ' Close the client connection.
            authStream.Close()
            Console.WriteLine("Client closed.")

        End Sub

        ' The following method is called when the authentication completes.
        Public Shared Sub EndAuthenticateCallback(ar As IAsyncResult)

            Console.WriteLine("Client ending authentication...")
            Dim authStream = CType(ar.AsyncState, NegotiateStream)
            Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel)

            ' End the asynchronous operation.
            authStream.EndAuthenticateAsClient(ar)

        End Sub

        ' The following method is called when the write operation completes.
        Public Shared Sub EndWriteCallback(ar As IAsyncResult)

            Console.WriteLine("Client ending write operation...")
            Dim authStream = CType(ar.AsyncState, NegotiateStream)

            ' End the asynchronous operation.
            authStream.EndWrite(ar)

        End Sub
    End Class

    ' The following class displays the properties of an AuthenticatedStream.
    Public Class AuthenticatedStreamReporter
        Public Shared Sub DisplayProperties(stream As AuthenticatedStream)
            Console.WriteLine("IsAuthenticated: {0}", stream.IsAuthenticated)
            Console.WriteLine("IsMutuallyAuthenticated: {0}", stream.IsMutuallyAuthenticated)
            Console.WriteLine("IsEncrypted: {0}", stream.IsEncrypted)
            Console.WriteLine("IsSigned: {0}", stream.IsSigned)
            Console.WriteLine("IsServer: {0}", stream.IsServer)
        End Sub
    End Class
End Namespace

Následující příklad kódu ukazuje stranu serveru připojení klienta-server, který používá NegotiateStream k ověření klienta a čtení zprávy odeslané klientem.

using System;
using System.Net;
using System.Net.Security;
using System.Net.Sockets;
using System.Security.Authentication;
using System.Security.Principal;
using System.Text;
using System.IO;
using System.Threading;

namespace Examples.NegotiateStreamExample
{
    public class AsynchronousAuthenticatingTcpListener
    {
        public static void Main()
        {
            // Create an IPv4 TCP/IP socket.
            TcpListener listener = new TcpListener(IPAddress.Any, 11000);
            // Listen for incoming connections.
            listener.Start();
            while (true)
            {
                TcpClient clientRequest;
                // Application blocks while waiting for an incoming connection.
                // Type CNTL-C to terminate the server.
                clientRequest = listener.AcceptTcpClient();
                Console.WriteLine("Client connected.");
                // A client has connected.
                try
                {
                    AuthenticateClient(clientRequest);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
            }
        }

        public static void AuthenticateClient(TcpClient clientRequest)
        {
            NetworkStream stream = clientRequest.GetStream();
            // Create the NegotiateStream.
            NegotiateStream authStream = new NegotiateStream(stream, false);
            // Save the current client and NegotiateStream instance
            // in a ClientState object.
            ClientState cState = new ClientState(authStream, clientRequest);
            // Listen for the client authentication request.
            Task authTask = authStream
                .AuthenticateAsServerAsync()
                .ContinueWith(task => { EndAuthenticateCallback(cState); });

            // Any exceptions that occurred during authentication are
            // thrown by the EndAuthenticateAsServer method.
            try
            {
                // This call blocks until the authentication is complete.
                authTask.Wait();
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Authentication failed - closing connection.");
                return;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Closing connection.");
                return;
            }

            Task<int> readTask = authStream
                .ReadAsync(cState.Buffer, 0, cState.Buffer.Length);

            readTask
                .ContinueWith((task) => { EndReadCallback(cState, task.Result); })
                .Wait();
            // Finished with the current client.
            authStream.Close();
            clientRequest.Close();
        }

        private static void EndAuthenticateCallback(ClientState cState)
        {
            // Get the saved data.
            NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream;
            Console.WriteLine("Ending authentication.");

            // Display properties of the authenticated client.
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} was authenticated using {1}.",
                id.Name,
                id.AuthenticationType
            );
        }

        private static void EndReadCallback(ClientState cState, int bytes)
        {
            NegotiateStream authStream = (NegotiateStream)cState.AuthenticatedStream;
            // Read the client message.
            try
            {
                cState.Message.Append(Encoding.UTF8.GetChars(cState.Buffer, 0, bytes));
                if (bytes != 0)
                {
                    Task<int> readTask = authStream.ReadAsync(cState.Buffer, 0, cState.Buffer.Length);
                    readTask
                        .ContinueWith(task => { EndReadCallback(cState, task.Result); })
                        .Wait();

                    return;
                }
            }
            catch (Exception e)
            {
                // A real application should do something
                // useful here, such as logging the failure.
                Console.WriteLine("Client message exception:");
                Console.WriteLine(e);
                return;
            }
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString());
        }
    }
    // ClientState is the AsyncState object.
    internal class ClientState
    {
        private StringBuilder _message = null;

        internal ClientState(AuthenticatedStream a, TcpClient theClient)
        {
            AuthenticatedStream = a;
            Client = theClient;
        }
        internal TcpClient Client { get; }

        internal AuthenticatedStream AuthenticatedStream { get; }

        internal byte[] Buffer { get; } = new byte[2048];

        internal StringBuilder Message
        {
            get { return _message ??= new StringBuilder(); }
        }
    }
}

Poznámky

NegotiateStream Třída slouží k ověřování a k zabezpečení informací přenášených mezi klientem a serverem. Pomocí NegotiateStreampříkazu můžete provést následující akce.

• Odešlete přihlašovací údaje klienta na server pro zosobnění nebo delegování.
• Vyžádání ověření serveru
• Před přenosem zašifrujte a/nebo podepište data.

Před přenosem informací musí být provedeno ověřování. Klienti požadují ověření pomocí synchronních AuthenticateAsClient metod, které blokují, dokud se ověřování nedokončí, nebo asynchronní BeginAuthenticateAsClient metody, které neblokují při čekání na dokončení ověření. Servery požadují ověřování pomocí synchronních AuthenticateAsServer nebo asynchronních BeginAuthenticateAsServer metod. Klient a volitelně i server se ověřuje pomocí protokolu zabezpečení Negotiate. Protokol Kerberos se používá k ověřování, pokud ho klient i server podporují; v opačném případě se použije protokol NTLM. Třída NegotiateStream provádí ověřování pomocí rozhraní SSPI (Security Support Provider Interface).

Pokud ověřování proběhne úspěšně, je nutné zkontrolovat IsEncrypted vlastnosti a IsSigned určit, jaké služby zabezpečení budou používány službou NegotiateStream zabezpečení při přenosu. IsMutuallyAuthenticated Zkontrolujte vlastnost a určete, jestli došlo k vzájemnému ověřování. Informace o vzdáleném klientovi nebo serveru můžete získat pomocí RemoteIdentity vlastnosti.

Pokud se ověření nezdaří, obdržíte nebo AuthenticationExceptionInvalidCredentialExceptiona . V takovém případě můžete znovu zkusit ověření pomocí jiného pověření.

Data odesíláte pomocí synchronních Write nebo asynchronních BeginWrite nebo WriteAsync metod. Přijímáte data pomocí synchronních Read nebo asynchronních ReadAsync nebo BeginRead metod. Pokud jsou povolené služby zabezpečení, jako je šifrování nebo podepisování, automaticky se použijí na vaše data NegotiateStream.

Přenáší NegotiateStream data pomocí datového proudu, který zadáte při vytváření NegotiateStream. Když zadáte tento podkladový datový proud, můžete určit, zda NegotiateStream zavření také podkladového datového proudu.

Konstruktory

Name	Description
NegotiateStream(Stream, Boolean)	Inicializuje novou instanci NegotiateStream třídy pomocí zadaného Stream a stream uzavření chování.
NegotiateStream(Stream)	Inicializuje novou instanci NegotiateStream třídy pomocí zadané Stream.

Vlastnosti

Name	Description
CanRead	Boolean Získá hodnotu, která určuje, zda je podkladový datový proud čitelný.
CanSeek	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud vyhledatelný.
CanTimeout	Boolean Získá hodnotu, která označuje, zda podkladový datový proud podporuje vypršení časových limitů.
CanWrite	Boolean Získá hodnotu, která označuje, zda je podkladový datový proud zapisovatelný.
ImpersonationLevel	Získá hodnotu, která označuje, jak může server používat přihlašovací údaje klienta.
InnerStream	Získá datový proud používaný tímto AuthenticatedStream způsobem pro odesílání a příjem dat. (Zděděno od AuthenticatedStream)
IsAuthenticated	Boolean Získá hodnotu, která označuje, zda ověřování bylo úspěšné.
IsEncrypted	Boolean Získá hodnotu, která označuje, zda se používá NegotiateStream šifrování dat.
IsMutuallyAuthenticated	Boolean Získá hodnotu, která určuje, zda byl server i klient ověřen.
IsServer	Boolean Získá hodnotu, která označuje, zda místní strana připojení používaná tímto NegotiateStream způsobem byla ověřena jako server.
IsSigned	Boolean Získá hodnotu, která označuje, zda jsou data odeslaná pomocí tohoto datového proudu podepsána.
LeaveInnerStreamOpen	Získá, zda datový proud používaný tímto AuthenticatedStream způsobem pro odesílání a příjem dat byl ponechán otevřený. (Zděděno od AuthenticatedStream)
Length	Získá délku podkladového datového proudu.
Position	Získá nebo nastaví aktuální pozici v podkladovém datovém proudu.
ReadTimeout	Získá nebo nastaví dobu, po kterou operace čtení blokuje čekání na data.
RemoteIdentity	Získá informace o identitě vzdálené strany sdílení tohoto ověřeného datového proudu.
WriteTimeout	Získá nebo nastaví dobu, po kterou operace zápisu blokuje čekání na data.

Metody

Name	Description
AuthenticateAsClient()	Volali klienti pro ověření klienta a volitelně i serveru v připojení klienta-server.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Volali klienti pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje, možnosti ověřování a vazbu kanálu.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Volali klienti pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje klienta a vazbu kanálu.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Volali klienti pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje a možnosti ověřování.
AuthenticateAsClient(NetworkCredential, String)	Volali klienti pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje klienta.
AuthenticateAsClientAsync()	Volali klienti, aby ověřili klienta a volitelně server, v připojení klienta-server jako asynchronní operace.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Volali klienti, aby ověřili klienta a volitelně server, v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadané přihlašovací údaje, možnosti ověřování a vazbu kanálu.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Volali klienti, aby ověřili klienta a volitelně server, v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadané přihlašovací údaje klienta a vazbu kanálu.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Volali klienti, aby ověřili klienta a volitelně server, v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadané přihlašovací údaje a možnosti ověřování.
AuthenticateAsClientAsync(NetworkCredential, String)	Volali klienti, aby ověřili klienta a volitelně server, v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadané přihlašovací údaje klienta.
AuthenticateAsServer()	Volal servery pro ověření klienta a volitelně i serveru v připojení klienta-server.
AuthenticateAsServer(ExtendedProtectionPolicy)	Volal servery pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadanou zásadu rozšířené ochrany.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Volal servery pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje serveru, možnosti ověřování a rozšířené zásady ochrany.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Volal servery pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje serveru a možnosti ověřování.
AuthenticateAsServerAsync()	Volal servery pro ověření klienta a volitelně i server v připojení klienta-server jako asynchronní operace.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Volal servery pro ověření klienta a volitelně i server v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadanou zásadu rozšířené ochrany.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Volal servery pro ověření klienta a volitelně i server v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadané přihlašovací údaje serveru, možnosti ověřování a rozšířené zásady ochrany.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Volal servery pro ověření klienta a volitelně i server v připojení klienta-server jako asynchronní operace. Proces ověřování používá zadané přihlašovací údaje serveru a možnosti ověřování.
BeginAuthenticateAsClient(AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření klienta a volitelně server v připojení klienta-server. Tato metoda neblokuje.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření klienta a volitelně server v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje a vazbu kanálu. Tato metoda neblokuje.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření klienta a volitelně server v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje, možnosti ověřování a vazbu kanálu. Tato metoda neblokuje.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření klienta a volitelně server v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje. Tato metoda neblokuje.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Volali klienti, aby zahájili asynchronní operaci pro ověření klienta a volitelně server v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje a možnosti ověřování. Tato metoda neblokuje.
BeginAuthenticateAsServer(AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření klienta a volitelně i serveru v připojení klienta-server. Tato metoda neblokuje.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadanou zásadu rozšířené ochrany. Tato metoda neblokuje.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje serveru, možnosti ověřování a rozšířené zásady ochrany. Tato metoda neblokuje.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Volá se servery, aby zahájily asynchronní operaci pro ověření klienta a volitelně i serveru v připojení klienta-server. Proces ověřování používá zadané přihlašovací údaje serveru a možnosti ověřování. Tato metoda neblokuje.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Zahájí asynchronní operaci čtení, která čte data z datového proudu a uloží je do zadaného pole.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Začíná asynchronní operace zápisu, která zapisuje Bytez zadané vyrovnávací paměti do datového proudu.
Close()	Zavře aktuální datový proud a uvolní všechny prostředky (například sokety a popisovače souborů) přidružené k aktuálnímu datovému proudu. Místo volání této metody se ujistěte, že je datový proud správně uvolněn. (Zděděno od Stream)
CopyTo(Stream, Int32)	Načte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyTo(Stream)	Přečte bajty z aktuálního datového proudu a zapíše je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadaného tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti a tokenu zrušení. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream, Int32)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu pomocí zadané velikosti vyrovnávací paměti. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CopyToAsync(Stream)	Asynchronně čte bajty z aktuálního datového proudu a zapisuje je do jiného datového proudu. Obě pozice datových proudů jsou rozšířeny počtem bajtů zkopírovaných. (Zděděno od Stream)
CreateWaitHandle()	Zastaralé. WaitHandle Přidělí objekt. (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané nástrojem Stream. (Zděděno od Stream)
Dispose(Boolean)	Uvolní nespravované prostředky používané NegotiateStream a volitelně uvolní spravované prostředky.
DisposeAsync()	Asynchronně uvolní nespravované a spravované prostředky používané nástrojem NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Ukončí čekající asynchronní operaci ověřování klienta, která byla spuštěna voláním BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Ukončí čekající asynchronní operaci ověřování klienta, která byla spuštěna voláním BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Ukončí asynchronní operaci čtení, která byla zahájena voláním BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Ukončí asynchronní operaci zápisu, která byla zahájena voláním BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
Flush()	Způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení.
FlushAsync()	Asynchronně vymaže všechny vyrovnávací paměti pro tento datový proud a způsobí zápis všech dat uložených do vyrovnávací paměti do podkladového zařízení. (Zděděno od Stream)
FlushAsync(CancellationToken)	Asynchronně zapíše veškerá data uložená do vyrovnávací paměti do podkladového zařízení.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
ObjectInvariant()	Zastaralé. Poskytuje podporu pro .Contract (Zděděno od Stream)
Read(Byte[], Int32, Int32)	Načte data z tohoto datového proudu a uloží je do zadaného pole.
Read(Span<Byte>)	Při přepsání v odvozené třídě přečte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Čte data asynchronně z tohoto datového proudu a ukládá je do zadaného pole.
ReadAsync(Byte[], Int32, Int32)	Asynchronně čte posloupnost bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAsync(Memory<Byte>, CancellationToken)	Čte data asynchronně z NegotiateStream oblasti bajtů a ukládá je do bajtového rozsahu paměti jako asynchronní operace.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Čte alespoň minimální počet bajtů z aktuálního datového proudu a posune pozici v datovém proudu o počet přečtených bajtů. (Zděděno od Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Asynchronně čte alespoň minimální počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu o počet přečtených bajtů a monitoruje žádosti o zrušení. (Zděděno od Stream)
ReadByte()	Přečte bajt ze streamu a posune pozici v rámci datového proudu o jeden bajt nebo vrátí -1, pokud je na konci datového proudu. (Zděděno od Stream)
ReadExactly(Byte[], Int32, Int32)	count Přečte počet bajtů z aktuálního datového proudu a posune pozici v rámci datového proudu. (Zděděno od Stream)
ReadExactly(Span<Byte>)	Přečte bajty z aktuálního datového proudu a posune pozici v rámci datového proudu, dokud buffer se nenaplní. (Zděděno od Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Asynchronně čte count počet bajtů z aktuálního datového proudu, posune pozici v rámci datového proudu a monitoruje požadavky na zrušení. (Zděděno od Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Asynchronně čte bajty z aktuálního datového proudu, posune pozici v rámci datového proudu, dokud buffer se nenaplní, a monitoruje žádosti o zrušení. (Zděděno od Stream)
Seek(Int64, SeekOrigin)	Vyhodí NotSupportedException.
SetLength(Int64)	Nastaví délku podkladového datového proudu.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)
Write(Byte[], Int32, Int32)	Pomocí zadané vyrovnávací paměti a posunu napište zadaný počet Bytes do podkladového datového proudu.
Write(ReadOnlySpan<Byte>)	Při přepsání v odvozené třídě zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu počtem zapsaných bajtů. (Zděděno od Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Zápis asynchronně zadaného Bytepočtu s do podkladového datového proudu
WriteAsync(Byte[], Int32, Int32)	Asynchronně zapíše posloupnost bajtů do aktuálního datového proudu a posune aktuální pozici v tomto datovém proudu o počet zapsaných bajtů. (Zděděno od Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Zápis asynchronně zadaného Bytepočtu s do podkladového datového proudu
WriteByte(Byte)	Zapíše bajt na aktuální pozici v datovém proudu a posune pozici v rámci datového proudu o jeden bajt. (Zděděno od Stream)

Metody rozšíření

Name	Description
ConfigureAwait(IAsyncDisposable, Boolean)	Konfiguruje, jak čekají na úlohy vrácené z asynchronního jednorázového použití.
CopyToAsync(Stream, PipeWriter, CancellationToken)	Asynchronně čte bajty ze zadaného objektu Stream a zapíše je do zadaného PipeWritertokenu zrušení.

Viz také

• Změny ověřování NTLM pro HTTPWebRequest ve verzi 3.5 SP1