NegotiateStream Třída

Definice

Obor názvů:

System.Net.Security

Sestavení:

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.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Text;

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

};


public ref class ASynchronousAuthenticatingTcpClient
{
private:
   static TcpClient^ client = nullptr;

public:
   void Main()
   {
      
      // 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 = gcnew IPEndPoint( ipAddress,11000 );
      
      // Create a TCP/IP socket.
      client = gcnew TcpClient;
      
      // Connect the socket to the remote endpoint.
      client->Connect( remoteEP );
      Console::WriteLine( L"Client connected to {0}.", remoteEP );
      
      // Ensure the client does not close when there is 
      // still data to be sent to the server.
      client->LingerState = (gcnew LingerOption( true,0 ));
      
      // Request authentication.
      NetworkStream^ clientStream = client->GetStream();
      NegotiateStream^ authStream = gcnew NegotiateStream( clientStream,false );
      
      // Pass the NegotiateStream as the AsyncState object 
      // so that it is available to the callback delegate.
      IAsyncResult^ ar = authStream->BeginAuthenticateAsClient( gcnew AsyncCallback( EndAuthenticateCallback ), authStream );
      
      Console::WriteLine( L"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.
      array<Byte>^message = Encoding::UTF8->GetBytes( L"Hello from the client." );
      ar = authStream->BeginWrite( message, 0, message->Length, gcnew AsyncCallback( EndWriteCallback ), authStream );
      
      ar->AsyncWaitHandle->WaitOne();
      Console::WriteLine( L"Sent {0} bytes.", message->Length );
      
      // Close the client connection.
      authStream->Close();
      Console::WriteLine( L"Client closed." );
   }


   // The following method is called when the authentication completes.
   static void EndAuthenticateCallback( IAsyncResult^ ar )
   {
      Console::WriteLine( L"Client ending authentication..." );
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
      
      // End the asynchronous operation.
      authStream->EndAuthenticateAsClient( ar );
      
      //         Console.WriteLine("AllowedImpersonation: {0}", authStream.AllowedImpersonation);
   }


   // The following method is called when the write operation completes.
   static void EndWriteCallback( IAsyncResult^ ar )
   {
      Console::WriteLine( L"Client ending write operation..." );
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(ar->AsyncState);
      
      // End the asynchronous operation.
      authStream->EndWrite( ar );
   }

};

void main()
{
   ASynchronousAuthenticatingTcpClient^ aatc = gcnew ASynchronousAuthenticatingTcpClient;
   aatc->Main();
}

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.dll>

using namespace System;
using namespace System::Net;
using namespace System::Net::Security;
using namespace System::Net::Sockets;
using namespace System::Security::Authentication;
using namespace System::Security::Principal;
using namespace System::Text;
using namespace System::IO;
using namespace System::Threading;

// ClientState is the AsyncState object.
private ref class ClientState
{
private:
   AuthenticatedStream^ authStream;
   TcpClient^ client;
   array<Byte>^buffer;
   StringBuilder^ message;
   ManualResetEvent^ waiter;

internal:
   ClientState( AuthenticatedStream^ a, TcpClient^ theClient )
   {
      authStream = a;
      client = theClient;
      message = nullptr;
      buffer = gcnew array<Byte>(2048);
      waiter = gcnew ManualResetEvent( false );
   }

internal:
   property TcpClient^ Client 
   {
      TcpClient^ get()
      {
         return client;
      }
   }

   property AuthenticatedStream^ AuthStream 
   {
      AuthenticatedStream^ get()
      {
         return authStream;
      }
  }

   property array<Byte>^ Buffer 
   {
      array<Byte>^ get()
      {
         return buffer;
      }

   }

   property StringBuilder^ Message 
   {
      StringBuilder^ get()
      {
         if ( message == nullptr )
                  message = gcnew StringBuilder;

         return message;
      }

   }

   property ManualResetEvent^ Waiter 
   {
      ManualResetEvent^ get()
      {
         return waiter;
      }

   }

};

public ref class AsynchronousAuthenticatingTcpListener
{
public:
   int Main()
   {
      
      // Create an IPv4 TCP/IP socket. 
      TcpListener^ listener = gcnew TcpListener( IPAddress::Any,11000 );
      
      // Listen for incoming connections.
      listener->Start();
      while ( true )
      {
         TcpClient^ clientRequest = nullptr;
         
         // Application blocks while waiting for an incoming connection.
         // Type CNTL-C to terminate the server.
         clientRequest = listener->AcceptTcpClient();
         Console::WriteLine( L"Client connected." );
         
         // A client has connected. 
         try
         {
            AuthenticateClient( clientRequest );
         }
         catch ( Exception^ e ) 
         {
            Console::WriteLine( e );
            continue;
         }

      }
   }


   static void AuthenticateClient( TcpClient^ clientRequest )
   {
      NetworkStream^ stream = clientRequest->GetStream();
      
      // Create the NegotiateStream.
      NegotiateStream^ authStream = gcnew NegotiateStream( stream,false );
      
      // Save the current client and NegotiateStream instance 
      // in a ClientState object.
      ClientState^ cState = gcnew ClientState( authStream,clientRequest );
      
      // Listen for the client authentication request.
      authStream->BeginAuthenticateAsServer( gcnew AsyncCallback( EndAuthenticateCallback ), cState );
      
      // Wait until the authentication completes.
      cState->Waiter->WaitOne();
      cState->Waiter->Reset();
      authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
      cState->Waiter->WaitOne();
      
      // Finished with the current client.
      authStream->Close();
      clientRequest->Close();
   }


   // The following method is invoked by the
   // BeginServerAuthenticate callback delegate.
   static void EndAuthenticateCallback( IAsyncResult^ ar )
   {
      
      // Get the saved data.
      ClientState^ cState = dynamic_cast<ClientState^>(ar->AsyncState);
      TcpClient^ clientRequest = cState->Client;
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(cState->AuthStream);
      Console::WriteLine( L"Ending authentication." );
      
      // Any exceptions that occurred during authentication are
      // thrown by the EndServerAuthenticate method.
      try
      {
         
         // This call blocks until the authentication is complete.
         authStream->EndAuthenticateAsServer( ar );
      }
      catch ( AuthenticationException^ e ) 
      {
         Console::WriteLine( e );
         Console::WriteLine( L"Authentication failed - closing connection." );
         cState->Waiter->Set();
         return;
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( e );
         Console::WriteLine( L"Closing connection." );
         cState->Waiter->Set();
         return;
      }

      
      // Display properties of the authenticated client.
      IIdentity^ id = authStream->RemoteIdentity;
      Console::WriteLine( L"{0} was authenticated using {1}.", id->Name, id->AuthenticationType );
      cState->Waiter->Set();
   }


   static void EndReadCallback( IAsyncResult^ ar )
   {
      
      // Get the saved data.
      ClientState^ cState = dynamic_cast<ClientState^>(ar->AsyncState);
      TcpClient^ clientRequest = cState->Client;
      NegotiateStream^ authStream = dynamic_cast<NegotiateStream^>(cState->AuthStream);
      
      // Get the buffer that stores the message sent by the client.
      int bytes = -1;
      
      // Read the client message.
      try
      {
         bytes = authStream->EndRead( ar );
         cState->Message->Append( Encoding::UTF8->GetChars( cState->Buffer, 0, bytes ) );
         if ( bytes != 0 )
         {
            authStream->BeginRead( cState->Buffer, 0, cState->Buffer->Length, gcnew AsyncCallback( EndReadCallback ), cState );
            return;
         }
      }
      catch ( Exception^ e ) 
      {
         
         // A real application should do something
         // useful here, such as logging the failure.
         Console::WriteLine( L"Client message exception:" );
         Console::WriteLine( e );
         cState->Waiter->Set();
         return;
      }

      IIdentity^ id = authStream->RemoteIdentity;
      Console::WriteLine( L"{0} says {1}", id->Name, cState->Message );
      cState->Waiter->Set();
   }

};

void main()
{
   AsynchronousAuthenticatingTcpListener^ aatl = gcnew AsynchronousAuthenticatingTcpListener;
   aatl->Main();
}

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

K ověřování použijte třídu NegotiateStream a pomozte zabezpečit informace přenášené mezi klientem a serverem. Pomocí NegotiateStreammůž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 metod AuthenticateAsClient, které blokují, dokud se ověřování nedokončí, nebo asynchronní metody BeginAuthenticateAsClient, které neblokují při čekání na dokončení ověřování. Servery požadují ověřování pomocí synchronních AuthenticateAsServer nebo asynchronních metod BeginAuthenticateAsServer. 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ě, musíte zkontrolovat vlastnosti IsEncrypted a IsSigned, abyste zjistili, jaké služby zabezpečení budou NegotiateStream používat k zabezpečení vašich dat během přenosu. Zkontrolujte vlastnost IsMutuallyAuthenticated a zjistěte, jestli došlo k vzájemnému ověřování. Informace o vzdáleném klientovi nebo serveru můžete získat pomocí vlastnosti RemoteIdentity.

Pokud ověřování selže, obdržíte AuthenticationException nebo InvalidCredentialException. 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 metod WriteAsync. Přijímáte data pomocí synchronních Read nebo asynchronních ReadAsync nebo metod BeginRead. Pokud jsou povolené služby zabezpečení, jako je šifrování nebo podepisování, automaticky se použijí na vaše data NegotiateStream.

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

Konstruktory

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

Vlastnosti

CanRead	Získá Boolean hodnotu, která označuje, zda je podkladový datový proud čitelný.
CanSeek	Získá Boolean hodnotu, která označuje, zda je podkladový datový proud vyhledatelný.
CanTimeout	Získá Boolean hodnotu, která označuje, zda podkladový datový proud podporuje vypršení časového limitu.
CanWrite	Získá Boolean 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 pro odesílání a příjem dat. (Zděděno od AuthenticatedStream)
IsAuthenticated	Získá Boolean hodnotu, která označuje, zda ověřování bylo úspěšné.
IsEncrypted	Získá Boolean hodnotu, která označuje, zda tato NegotiateStream používá šifrování dat.
IsMutuallyAuthenticated	Získá Boolean hodnotu, která označuje, zda byl server i klient ověřen.
IsServer	Získá Boolean hodnotu, která označuje, zda místní strana připojení používaná tímto NegotiateStream byla ověřena jako server.
IsSigned	Získá Boolean hodnotu, která označuje, zda jsou data odesílaná pomocí tohoto datového proudu podepsána.
LeaveInnerStreamOpen	Získá, zda datový proud používaný tímto AuthenticatedStream 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

AuthenticateAsClient()	Volali klienti pro ověření klienta a volitelně i serveru v připojení klienta-server.
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, 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, 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.
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í.
AuthenticateAsClientAsync()	Volali klienti, aby ověřili klienta a volitelně server, v připojení klienta-server jako asynchronní operace.
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, 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, 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.
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í.
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)	Zahájí asynchronní operaci zápisu, která zapisuje Bytes ze 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)	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)
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)
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)
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)	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, 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)
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru sloužícího ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
CreateWaitHandle()	Zastaralé. Přidělí objekt WaitHandle. (Zděděno od Stream)
Dispose()	Uvolní všechny prostředky používané 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é 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 objektu MarshalByRefObject. (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)	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(Byte[], Int32, Int32, CancellationToken)	Čte data asynchronně z tohoto datového proudu a ukládá je do zadaného pole.
ReadAsync(Memory<Byte>, CancellationToken)	Čte data asynchronně z NegotiateStream a ukládá je v bajtovém 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)	Přečte count 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 se buffer 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 se buffer nenaplní, a monitoruje žádosti o zrušení. (Zděděno od Stream)
Seek(Int64, SeekOrigin)	Vyvolá 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)	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(Byte[], Int32, Int32, CancellationToken)	Napište asynchronně zadaný počet Bytes do podkladového datového proudu.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Napište asynchronně zadaný počet Bytes 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í

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

Viz také

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