NegotiateStream Classe

Definizione

Spazio dei nomi:

System.Net.Security

Assembly:

System.Net.Security.dll

Source:

NegotiateStream.cs

Fornisce un flusso che utilizza il protocollo di sicurezza Negotiate per autenticare il client e, facoltativamente, il server, nella 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 .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 per NegotiateStream 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 NegotiateStream classe 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 server.

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

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

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

Se l'autenticazione ha esito negativo, si riceverà un oggetto AuthenticationException o .InvalidCredentialException In questo caso, è possibile ritentare l'autenticazione con credenziali diverse.

I dati vengono inviati usando i metodi o sincroni Write o WriteAsync asincroniBeginWrite. I dati vengono ricevuti usando i Read metodi o sincroni o BeginRead asincroniReadAsync. Se i servizi di sicurezza, ad esempio la crittografia o la firma, vengono applicati automaticamente ai dati da NegotiateStream.

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

Costruttori

NegotiateStream(Stream)	Inizializza una nuova istanza della classe NegotiateStream usando il Stream specificato.
NegotiateStream(Stream, Boolean)	Inizializza una nuova istanza della classe NegotiateStream tramite l'oggetto Stream specificato e il comportamento di chiusura del flusso.

Proprietà

CanRead	Ottiene un valore Booleanche indica se il flusso sottostante è leggibile.
CanSeek	Ottiene un valore Boolean che indica se il flusso sottostante consente le ricerche.
CanTimeout	Ottiene un valore Boolean che indica se il flusso sottostante supporta i timeout.
CanWrite	Ottiene un valore Boolean che indica se è possibile scrivere nel flusso sottostante.
ImpersonationLevel	Ottiene un valore che indica il modo in cui il server può utilizzare le credenziali del client.
InnerStream	Ottiene il flusso utilizzato dalla classe AuthenticatedStream per inviare e ricevere dati. (Ereditato da AuthenticatedStream)
IsAuthenticated	Ottiene un valore Boolean che indica se l'autenticazione è stata effettuata con esito positivo.
IsEncrypted	Ottiene un valore Boolean che indica se la classe NegotiateStream utilizza la crittografia dei dati.
IsMutuallyAuthenticated	Ottiene un valore Boolean che indica se il server e il client sono stati entrambi autenticati.
IsServer	Ottiene un valore Boolean che indica se il lato locale della connessione utilizzato da questa classe NegotiateStream è stato autenticato come il server.
IsSigned	Ottiene un valore Boolean che indica se i dati inviati utilizzando questo flusso vengono firmati.
LeaveInnerStreamOpen	Consente di sapere se il flusso utilizzato dalla classe AuthenticatedStream per inviare e ricevere 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 l'intervallo di tempo per il quale un'operazione di lettura si blocca in attesa dei dati.
RemoteIdentity	Ottiene informazioni sull'identità della parte remota che condivide questo flusso autenticato.
WriteTimeout	Ottiene o imposta l'intervallo di tempo durante il quale un'operazione di scrittura si blocca in attesa dei dati.

Metodi

AuthenticateAsClient()	Viene chiamato dai client per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	Viene chiamato dai client per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza l'associazione di canale e le credenziali del client specificate.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato dai client per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza l'associazione di canale, le opzioni di autenticazione e la credenziale specificate.
AuthenticateAsClient(NetworkCredential, String)	Viene chiamato dai client per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali del client specificate.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato dai client per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali e le opzioni di autenticazione specificate.
AuthenticateAsClientAsync()	Viene chiamato per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come operazione asincrona.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	Viene chiamato per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come operazione asincrona. Il processo di autenticazione utilizza l'associazione di canale e le credenziali del client specificate.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come operazione asincrona. Il processo di autenticazione utilizza l'associazione di canale, le opzioni di autenticazione e la credenziale specificate.
AuthenticateAsClientAsync(NetworkCredential, String)	Viene chiamato per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come operazione asincrona. Il processo di autenticazione utilizza le credenziali del client specificate.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come operazione asincrona. Il processo di autenticazione utilizza le credenziali e le opzioni di autenticazione specificate.
AuthenticateAsServer()	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server.
AuthenticateAsServer(ExtendedProtectionPolicy)	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza i criteri di protezione estesa specificati.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali del server, le opzioni di autenticazione e i criteri di protezione estesa specificati.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali del server e le opzioni di autenticazione specificate.
AuthenticateAsServerAsync()	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come un'operazione asincrona.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come un'operazione asincrona. Il processo di autenticazione utilizza i criteri di protezione estesa specificati.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come un'operazione asincrona. Il processo di autenticazione utilizza le credenziali del server, le opzioni di autenticazione e i criteri di protezione estesa specificati.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	Viene chiamato dai server per l'autenticazione del client e, facoltativamente, del server, in una connessione client-server come un'operazione asincrona. Il processo di autenticazione utilizza le credenziali del server e le opzioni di autenticazione specificate.
BeginAuthenticateAsClient(AsyncCallback, Object)	Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Questo metodo non si blocca.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali e l'associazione di canale specificate. Questo metodo non si blocca.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza l'associazione di canale, le opzioni di autenticazione e le credenziali specificate. Questo metodo non si blocca.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali specificate. Questo metodo non si blocca.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Viene chiamato dai client per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali e le opzioni di autenticazione specificate. Questo metodo non si blocca.
BeginAuthenticateAsServer(AsyncCallback, Object)	Viene chiamato dai server per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Questo metodo non si blocca.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	Viene chiamato dai server per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza i criteri di protezione estesa specificati. Questo metodo non si blocca.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Viene chiamato dai server per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali del server, le opzioni di autenticazione e i criteri di protezione estesa specificati. Questo metodo non si blocca.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	Viene chiamato dai server per avviare un'operazione asincrona di autenticazione del client e, facoltativamente, del server, in una connessione client-server. Il processo di autenticazione utilizza le credenziali del server e le opzioni di autenticazione specificate. Questo metodo non si blocca.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di lettura asincrona dei dati del flusso, archiviandoli nella matrice specificata.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Avvia un'operazione di scrittura asincrona che scrive i Byte dal buffer specificato nel flusso.
Close()	Chiude il flusso corrente e libera le risorse, come socket e handle di file, ad esso associate. Anziché 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 dal numero di byte copiati. (Ereditato da Stream)
CopyTo(Stream, Int32)	Legge tutti i byte dal flusso corrente e li scrive in un altro flusso, usando una dimensione di buffer specificata. Entrambe le posizioni dei flussi sono avanzate dal 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 dal 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 dal numero di byte copiati. (Ereditato da Stream)
CopyToAsync(Stream, Int32)	Legge in modo asincrono tutti i byte dal flusso corrente e li scrive in un altro flusso, utilizzando una dimensione di buffer specificata. Entrambe le posizioni dei flussi sono avanzate dal 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 di buffer specificata e un token di annullamento. Entrambe le posizioni dei flussi sono avanzate dal numero di byte copiati. (Ereditato da Stream)
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
CreateWaitHandle()	Obsoleti. Alloca un oggetto WaitHandle. (Ereditato da Stream)
Dispose()	Rilascia tutte le risorse usate da Stream. (Ereditato da Stream)
Dispose(Boolean)	Rilascia le risorse non gestite usate da NegotiateStream e, facoltativamente, le risorse gestite.
DisposeAsync()	Consente di liberare in modo asincrono le risorse non gestite e gestite usate da NegotiateStream.
EndAuthenticateAsClient(IAsyncResult)	Termina un'operazione di autenticazione asincrona del client avviata con la chiamata del metodo BeginAuthenticateAsClient.
EndAuthenticateAsServer(IAsyncResult)	Termina un'operazione di autenticazione asincrona del client avviata con la chiamata del metodo BeginAuthenticateAsServer.
EndRead(IAsyncResult)	Termina un'operazione di lettura asincrona avviata con la chiamata del metodo BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).
EndWrite(IAsyncResult)	Termina un'operazione di scrittura asincrona avviata con la chiamata del metodo BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Flush()	Consente la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante.
FlushAsync()	Cancella in modo asincrono i dati di tutti i buffer del flusso e determina la scrittura dei dati memorizzati nel buffer nel dispositivo sottostante. (Ereditato da Stream)
FlushAsync(CancellationToken)	Scrive in modo asincrono i dati memorizzati nel buffer nel dispositivo sottostante.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetType()	Ottiene l'oggetto 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 dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
ObjectInvariant()	Obsoleti. Fornisce supporto per un oggetto Contract. (Ereditato da Stream)
Read(Byte[], Int32, Int32)	Legge i dati da questo flusso e li archivia nella matrice specificata.
Read(Span<Byte>)	Quando ne viene eseguito l'override in una classe derivata, legge una sequenza di byte dal flusso corrente e passa alla posizione successiva all'interno del flusso corrente 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 passa alla posizione successiva nel 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 da 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 avanza 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, avanza 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 corrente all'interno del flusso di un byte o restituisce -1 se si trova alla fine del flusso. (Ereditato da Stream)
ReadExactly(Byte[], Int32, Int32)	count Legge il numero di byte dal flusso corrente e avanza la posizione all'interno del flusso. (Ereditato da Stream)
ReadExactly(Span<Byte>)	Legge i byte dal flusso corrente e avanza la posizione all'interno del flusso finché non buffer viene riempita. (Ereditato da Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Legge in modo count asincrono il numero di byte dal flusso corrente, sposta 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, avanza la posizione all'interno del flusso finché non buffer viene riempita e monitora le richieste di annullamento. (Ereditato da Stream)
Seek(Int64, SeekOrigin)	Genera l'eccezione 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)	Consente di scrivere il numero specificato di Byte nel flusso sottostante, utilizzando il buffer e l'offset specificati.
Write(ReadOnlySpan<Byte>)	Quando ne viene eseguito l'override in una classe derivata, scrive una sequenza di byte nel flusso corrente e passa alla posizione successiva all'interno del flusso corrente 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 passa alla posizione successiva nel flusso in base al numero di byte scritti. (Ereditato da Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Scrive in modo asincrono il numero specificato di Byte nel flusso sottostante.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Scrive in modo asincrono il numero specificato di Byte nel flusso sottostante.
WriteByte(Byte)	Scrive un byte nella posizione corrente del flusso e sposta in avanti di un byte la posizione del flusso. (Ereditato da Stream)

Metodi di estensione

ConfigureAwait(IAsyncDisposable, Boolean)

Consente di configurare la modalità di esecuzione delle espressioni await per le attività restituite da un elemento disposable asincrono.

Vedi anche

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