NegotiateStream Classe

Definizione

Spazio dei nomi:

System.Net.Security

Assembly:

System.Net.Security.dll

Origine:

NegotiateStream.cs

Fornisce un flusso che usa il protocollo di sicurezza Negotiate per autenticare il client e, facoltativamente, nel server di comunicazione client-server.

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

Ereditarietà

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Esempio

Nell'esempio seguente viene illustrato il lato client di una connessione client-server che usa il NegotiateStream. Il client esegue l'autenticazione e invia un messaggio al server in modo asincrono.

#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

Nell'esempio di codice seguente viene illustrato il lato server di una connessione client-server che usa il NegotiateStream per autenticare il client e leggere un messaggio inviato dal client.

#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(); }
        }
    }
}

Commenti

Usare la classe NegotiateStream per l'autenticazione e per proteggere le informazioni trasmesse tra un client e un server. Usando NegotiateStream, è possibile eseguire le operazioni seguenti.

• Inviare le credenziali del client al server per la rappresentazione o la delega.

• Richiedere l'autenticazione del server.

• Crittografare e/o firmare i dati prima di trasmetterli.

L'autenticazione deve essere eseguita prima di trasmettere informazioni. I client richiedono l'autenticazione usando i metodi AuthenticateAsClient sincroni, che bloccano fino al completamento dell'autenticazione o i metodi di BeginAuthenticateAsClient asincroni, che non si bloccano durante l'attesa del completamento dell'autenticazione. I server richiedono l'autenticazione usando il AuthenticateAsServer sincrono o i metodi di BeginAuthenticateAsServer asincroni. Il client, e facoltativamente il server, viene autenticato usando il protocollo di sicurezza Negotiate. Il protocollo Kerberos viene usato per l'autenticazione se sia il client che il server lo supportano; in caso contrario, viene utilizzato NTLM. La classe NegotiateStream esegue l'autenticazione usando Security Support Provider Interface (SSPI).

Quando l'autenticazione ha esito positivo, è necessario controllare le proprietà IsEncrypted e IsSigned per determinare quali servizi di sicurezza verranno usati dal NegotiateStream per proteggere i dati durante la trasmissione. Controllare la proprietà IsMutuallyAuthenticated per determinare se si è verificata l'autenticazione reciproca. È possibile ottenere informazioni sul client o sul server remoto usando la proprietà RemoteIdentity.

Se l'autenticazione non riesce, si riceverà un AuthenticationException o un InvalidCredentialException. In questo caso, è possibile ritentare l'autenticazione con credenziali diverse.

I dati vengono inviati usando il Write sincrono o i metodi asincroni BeginWrite o WriteAsync. Si ricevono dati usando i metodi ReadAsync asincroni o sincroni Read o BeginRead. Se i servizi di sicurezza, ad esempio la crittografia o la firma, vengono applicati automaticamente ai dati dal NegotiateStream.

Il NegotiateStream trasmette i dati usando un flusso fornito durante la creazione del NegotiateStream. Quando si specifica questo flusso sottostante, è possibile specificare se chiudere il NegotiateStream chiude anche il flusso sottostante.

Costruttori

NegotiateStream(Stream)	Inizializza una nuova istanza della classe NegotiateStream utilizzando il Streamspecificato.
NegotiateStream(Stream, Boolean)	Inizializza una nuova istanza della classe NegotiateStream utilizzando il comportamento di chiusura del flusso e del Stream specificato.

Proprietà

CanRead	Ottiene un valore Boolean che indica se il flusso sottostante è leggibile.
CanSeek	Ottiene un valore Boolean che indica se il flusso sottostante è ricercabile.
CanTimeout	Ottiene un valore Boolean che indica se il flusso sottostante supporta i timeout.
CanWrite	Ottiene un valore Boolean che indica se il flusso sottostante è scrivibile.
ImpersonationLevel	Ottiene un valore che indica come il server può usare le credenziali del client.
InnerStream	Ottiene il flusso utilizzato da questo AuthenticatedStream per l'invio e la ricezione di dati. (Ereditato da AuthenticatedStream)
IsAuthenticated	Ottiene un valore Boolean che indica se l'autenticazione ha avuto esito positivo.
IsEncrypted	Ottiene un valore Boolean che indica se questa NegotiateStream utilizza la crittografia dei dati.
IsMutuallyAuthenticated	Ottiene un valore Boolean che indica se sia il server che il client sono stati autenticati.
IsServer	Ottiene un valore Boolean che indica se il lato locale della connessione utilizzata da questo NegotiateStream è stato autenticato come server.
IsSigned	Ottiene un valore Boolean che indica se i dati inviati tramite questo flusso sono firmati.
LeaveInnerStreamOpen	Ottiene un valore che indica se il flusso utilizzato da questo AuthenticatedStream per l'invio e la ricezione di dati è stato lasciato aperto. (Ereditato da AuthenticatedStream)
Length	Ottiene la lunghezza del flusso sottostante.
Position	Ottiene o imposta la posizione corrente nel flusso sottostante.
ReadTimeout	Ottiene o imposta la quantità di tempo in cui un'operazione di lettura blocca l'attesa dei dati.
RemoteIdentity	Ottiene informazioni sull'identità dell'entità remota che condivide questo flusso autenticato.
WriteTimeout	Ottiene o imposta la quantità di tempo in cui un'operazione di scrittura blocca l'attesa dei dati.

Metodi

AuthenticateAsClient()	Chiamato dai client per autenticare il client e, facoltativamente, il server in una connessione client-server.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Chiamato dai client per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali client specificate e l'associazione di canale.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai client per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali, le opzioni di autenticazione e l'associazione di canale specificate.
AuthenticateAsClient(NetworkCredential, String)	Chiamato dai client per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali client specificate.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai client per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali e le opzioni di autenticazione specificate.
AuthenticateAsClientAsync()	Chiamato dai client per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Chiamato dai client per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa le credenziali client specificate e l'associazione di canale.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai client per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa le credenziali, le opzioni di autenticazione e l'associazione di canale specificate.
AuthenticateAsClientAsync(NetworkCredential, String)	Chiamato dai client per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa le credenziali client specificate.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai client per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa le credenziali e le opzioni di autenticazione specificate.
AuthenticateAsServer()	Chiamato dai server per autenticare il client e, facoltativamente, il server in una connessione client-server.
AuthenticateAsServer(ExtendedProtectionPolicy)	Chiamato dai server per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa i criteri di protezione estesa specificati.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai server per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali del server, le opzioni di autenticazione e i criteri di protezione estesi specificati.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai server per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali del server e le opzioni di autenticazione specificate.
AuthenticateAsServerAsync()	Chiamato dai server per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Chiamato dai server per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa i criteri di protezione estesa specificati.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai server per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa le credenziali del server, le opzioni di autenticazione e i criteri di protezione estesi specificati.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Chiamato dai server per autenticare il client e facoltativamente il server in una connessione client-server come operazione asincrona. Il processo di autenticazione usa le credenziali del server e le opzioni di autenticazione specificate.
BeginAuthenticateAsClient(AsyncCallback, Object)	Chiamato dai client per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Questo metodo non blocca.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Chiamato dai client per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali e l'associazione di canale specificate. Questo metodo non blocca.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chiamato dai client per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali, le opzioni di autenticazione e l'associazione di canale specificate. Questo metodo non blocca.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Chiamato dai client per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali specificate. Questo metodo non blocca.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chiamato dai client per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali e le opzioni di autenticazione specificate. Questo metodo non blocca.
BeginAuthenticateAsServer(AsyncCallback, Object)	Chiamato dai server per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Questo metodo non blocca.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Chiamato dai server per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa i criteri di protezione estesa specificati. Questo metodo non blocca.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chiamato dai server per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali del server, le opzioni di autenticazione e i criteri di protezione estesi specificati. Questo metodo non blocca.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Chiamato dai server per avviare un'operazione asincrona per autenticare il client e, facoltativamente, il server in una connessione client-server. Il processo di autenticazione usa le credenziali del server e le opzioni di autenticazione specificate. Questo metodo non blocca.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di lettura asincrona che legge i dati dal flusso e li archivia nella matrice specificata.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di scrittura asincrona che scrive Bytes dal buffer specificato al flusso.
Close()	Chiude il flusso corrente e rilascia tutte le risorse (ad esempio socket e handle di file) associate al flusso corrente. Invece di chiamare questo metodo, assicurarsi che il flusso sia eliminato correttamente. (Ereditato da Stream)
CopyTo(Stream)	Legge i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyTo(Stream, Int32)	Legge i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del buffer specificata. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando un token di annullamento specificato. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del buffer specificata. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione del buffer e un token di annullamento specificati. Entrambe le posizioni dei flussi sono avanzate in base al numero di byte copiati. (Ereditato da Stream)
CreateObjRef(Type)	Crea un oggetto che contiene tutte le informazioni pertinenti necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleti. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate dal Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate dal NegotiateStream e, facoltativamente, rilascia le risorse gestite.
DisposeAsync()	Rilascia in modo asincrono le risorse non gestite e gestite usate dal NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Termina un'operazione di autenticazione client asincrona in sospeso avviata con una chiamata a BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Termina un'operazione di autenticazione client asincrona in sospeso avviata con una chiamata a BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Termina un'operazione di lettura asincrona avviata con una chiamata a BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona avviata con una chiamata a BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Flush()	Fa sì che tutti i dati memorizzati nel buffer vengano scritti nel dispositivo sottostante.
FlushAsync()	Cancella in modo asincrono tutti i buffer per questo flusso e determina la scrittura di tutti i dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da Stream)
FlushAsync(CancellationToken)	Scrive in modo asincrono tutti i dati memorizzati nel buffer nel dispositivo sottostante.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene il Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Obsoleti. Fornisce il supporto per un Contract. (Ereditato da Stream)
Read(Byte[], Int32, Int32)	Legge i dati da questo flusso e li archivia nella matrice specificata.
Read(Span<Byte>)	Quando sottoposto a override in una classe derivata, legge una sequenza di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32)	Legge in modo asincrono una sequenza di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Legge i dati in modo asincrono da questo flusso e li archivia nella matrice specificata.
ReadAsync(Memory<Byte>, CancellationToken)	Legge i dati in modo asincrono dalla NegotiateStream e li archivia in un intervallo di memoria di byte come operazione asincrona.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Legge almeno un numero minimo di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso in base al numero di byte letti. (Ereditato da Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Legge in modo asincrono almeno un numero minimo di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso in base al numero di byte letti e monitora le richieste di annullamento. (Ereditato da Stream)
ReadByte()	Legge un byte dal flusso e sposta in avanti la posizione all'interno del flusso di un byte oppure restituisce -1 se alla fine del flusso. (Ereditato da Stream)
ReadExactly(Byte[], Int32, Int32)	Legge count numero di byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso. (Ereditato da Stream)
ReadExactly(Span<Byte>)	Legge i byte dal flusso corrente e sposta in avanti la posizione all'interno del flusso fino a quando il buffer non viene riempito. (Ereditato da Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo asincrono count numero di byte dal flusso corrente, sposta in avanti la posizione all'interno del flusso e monitora le richieste di annullamento. (Ereditato da Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Legge in modo asincrono i byte dal flusso corrente, sposta la posizione all'interno del flusso fino a quando il buffer non viene riempito e monitora le richieste di annullamento. (Ereditato da Stream)
Seek(Int64, SeekOrigin)	Genera NotSupportedException.
SetLength(Int64)	Imposta la lunghezza del flusso sottostante.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
Write(Byte[], Int32, Int32)	Scrivere il numero specificato di Bytenel flusso sottostante usando il buffer e l'offset specificati.
Write(ReadOnlySpan<Byte>)	Quando sottoposto a override in una classe derivata, scrive una sequenza di byte nel flusso corrente e sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32)	Scrive in modo asincrono una sequenza di byte nel flusso corrente e sposta in avanti la posizione corrente all'interno del flusso in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Scrivere in modo asincrono il numero specificato di Bytenel flusso sottostante.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Scrivere in modo asincrono il numero specificato di Bytenel flusso sottostante.
WriteByte(Byte)	Scrive un byte nella posizione corrente nel flusso e sposta in avanti la posizione all'interno del flusso di un byte. (Ereditato da Stream)

Metodi di estensione

CopyToAsync(Stream, PipeWriter, CancellationToken)	Legge in modo asincrono i byte dal Stream e li scrive nel PipeWriterspecificato usando un token di annullamento.
ConfigureAwait(IAsyncDisposable, Boolean)	Configura il modo in cui verranno eseguite le attese nelle attività restituite da un oggetto eliminabile asincrono.

Vedi anche

• Modifiche all'autenticazione NTLM per HTTPWebRequest nella versione 3.5 SP1