NegotiateStream Klasse

Definition

Stellt einen Stream bereit, der mit dem Sicherheitsprotokoll Negotiate den Client und optional den Server für die Kommunikation zwischen Client und Server authentifiziert.

public ref class NegotiateStream : System::Net::Security::AuthenticatedStream
public class NegotiateStream : System.Net.Security.AuthenticatedStream
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public class NegotiateStream : System.Net.Security.AuthenticatedStream
type NegotiateStream = class
    inherit AuthenticatedStream
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
type NegotiateStream = class
    inherit AuthenticatedStream
Public Class NegotiateStream
Inherits AuthenticatedStream
Vererbung
Vererbung
Attribute

Beispiele

Im folgenden Beispiel wird die Clientseite einer Clientserververbindung veranschaulicht, die die NegotiateStream. Der Client authentifiziert sich und sendet asynchron eine Nachricht an den Server.

#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

Im folgenden Codebeispiel wird die Serverseite einer Clientserververbindung veranschaulicht, die zum NegotiateStream Authentifizieren des Clients verwendet wird, und eine vom Client gesendete Nachricht lesen.

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

Hinweise

Verwenden Sie die Klasse für die NegotiateStream Authentifizierung, und helfen Sie bei der Sicherung von Informationen, die zwischen einem Client und einem Server übertragen werden. Mithilfe von NegotiateStream, können Sie folgendes ausführen.

  • Senden Sie die Anmeldeinformationen des Clients an den Server für Identitätswechsel oder Delegierung.

  • Anfordern der Serverauthentifizierung.

  • Verschlüsseln und/oder signieren Sie Daten, bevor Sie sie übertragen.

Die Authentifizierung muss vor der Übermittlung von Informationen ausgeführt werden. Clients fordern die Authentifizierung mithilfe der synchronen AuthenticateAsClient Methoden an, die blockieren, bis die Authentifizierung abgeschlossen ist, oder die asynchronen BeginAuthenticateAsClient Methoden, die beim Warten auf den Abschluss der Authentifizierung nicht blockiert werden. Server fordern die Authentifizierung mithilfe der synchronen AuthenticateAsServer oder asynchronen BeginAuthenticateAsServer Methoden an. Der Client und optional der Server werden mithilfe des Verhandlungssicherheitsprotokolls authentifiziert. Das Kerberos-Protokoll wird für die Authentifizierung verwendet, wenn client- und serverseitig unterstützt wird; andernfalls wird NTLM verwendet. Die NegotiateStream Klasse führt die Authentifizierung mithilfe der SSPI(Security Support Provider Interface) aus.

Wenn die Authentifizierung erfolgreich verläuft, müssen Sie die IsEncrypted Und-Eigenschaften IsSigned überprüfen, um zu ermitteln, welche Sicherheitsdienste von den NegotiateStream Sicherheitsdiensten verwendet werden, um Ihre Daten während der Übertragung zu sichern. Überprüfen Sie die IsMutuallyAuthenticated Eigenschaft, um festzustellen, ob die gegenseitige Authentifizierung aufgetreten ist. Mithilfe der Eigenschaft können Sie Informationen über den RemoteIdentity Remoteclient oder den Server abrufen.

Wenn die Authentifizierung fehlschlägt, erhalten Sie eine AuthenticationException oder eine InvalidCredentialException. In diesem Fall können Sie die Authentifizierung mit einer anderen Anmeldeinformationen wiederholen.

Sie senden Daten mithilfe der synchronen oder asynchronen oder asynchronen Write BeginWrite Oder WriteAsync Methoden. Sie erhalten Daten mithilfe der synchronen oder asynchronen oder asynchronen Read ReadAsync Oder BeginRead Methoden. Wenn Sicherheitsdienste wie Verschlüsselung oder Signatur aktiviert sind, werden diese automatisch von der NegotiateStream.

Die NegotiateStream Daten werden mithilfe eines Datenstroms übertragen, den Sie beim Erstellen des NegotiateStreamDatenstroms angeben. Wenn Sie diesen zugrunde liegenden Datenstrom angeben, können Sie angeben, ob das Schließen des NegotiateStream zugrunde liegenden Datenstroms ebenfalls geschlossen wird.

Konstruktoren

NegotiateStream(Stream)

Initialisiert eine neue Instanz der NegotiateStream-Klasse mit dem angegebenen Stream.

NegotiateStream(Stream, Boolean)

Verwendet den angegebenen NegotiateStream und das Schlussverhalten des Streams zum Initialisieren einer neuen Instanz der Stream-Klasse.

Eigenschaften

CanRead

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream gelesen werden kann.

CanSeek

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream durchsucht werden kann.

CanTimeout

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream Timeouts unterstützt.

CanWrite

Ruft einen Boolean-Wert ab, der angibt, ob im zugrunde liegenden Stream geschrieben werden kann.

ImpersonationLevel

Ruft einen Wert ab, der angibt, wie der Server die Clientanmeldeinformationen verwenden kann.

InnerStream

Ruft den von diesem AuthenticatedStream verwendeten Stream zum Senden und Empfangen von Daten ab.

(Geerbt von AuthenticatedStream)
IsAuthenticated

Ruft einen Boolean-Wert ab, der angibt, ob die Authentifizierung erfolgreich war.

IsEncrypted

Ruft einen Boolean-Wert ab, der angibt, ob dieser NegotiateStream verschlüsselte Daten verwendet.

IsMutuallyAuthenticated

Ruft einen Boolean-Wert ab, der angibt, ob sowohl der Server als auch der Client authentifiziert wurden.

IsServer

Ruft einen Boolean-Wert ab, der angibt, ob die lokale, von diesem NegotiateStream verwendete Seite der Verbindung als Server authentifiziert wurde.

IsSigned

Ruft einen Boolean-Wert ab, der angibt, ob die mit diesem Stream gesendeten Daten signiert sind.

LeaveInnerStreamOpen

Ruft ab, ob der zum Senden und Empfangen von Daten von diesem AuthenticatedStream verwendete Stream weiterhin geöffnet ist.

(Geerbt von AuthenticatedStream)
Length

Ruft die Länge des zugrunde liegenden Streams ab.

Position

Ruft die aktuelle Position im zugrunde liegenden Stream ab oder legt diese fest.

ReadTimeout

Ruft die Zeitspanne ab, in der ein Lesevorgang während des Wartens auf Daten blockiert wird, oder legt diese fest.

RemoteIdentity

Ruft Informationen zur Identität der Remoteseite ab, für die dieser authentifizierte Stream freigegeben ist.

WriteTimeout

Ruft die Zeitspanne ab, in der ein Schreibvorgang während des Wartens auf Daten blockiert wird, oder legt diese fest.

Methoden

AuthenticateAsClient()

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen und die Channelbindung verwendet.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und die Channelbindung verwendet.

AuthenticateAsClient(NetworkCredential, String)

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen verwendet.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Beim Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und Authentifizierungsoptionen verwendet.

AuthenticateAsClientAsync()

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen und die Channelbindung verwendet.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und die Channelbindung verwendet.

AuthenticateAsClientAsync(NetworkCredential, String)

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen verwendet.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen. Beim Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und Authentifizierungsoptionen verwendet.

AuthenticateAsServer()

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen.

AuthenticateAsServer(ExtendedProtectionPolicy)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess wird die angegebene erweiterte Schutzrichtlinie verwendet.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und die erweiterte Schutzrichtlinie verwendet.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Beim Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen und die angegebenen Authentifizierungsoptionen verwendet.

AuthenticateAsServerAsync()

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang.

AuthenticateAsServerAsync(ExtendedProtectionPolicy)

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang. Für den Authentifizierungsprozess wird die angegebene erweiterte Schutzrichtlinie verwendet.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang. Für den Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und die erweiterte Schutzrichtlinie verwendet.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang. Beim Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen und die angegebenen Authentifizierungsoptionen verwendet.

BeginAuthenticateAsClient(AsyncCallback, Object)

Wird bei einer Client-/Serververbindung von Clients zum Starten eines asynchronen Vorgangs zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Diese Methode wird nicht blockiert.

BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)

Wird bei einer Client-/Serververbindung von Clients zum Starten eines asynchronen Vorgangs zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und die Channelbindung verwendet. Diese Methode wird nicht blockiert.

BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Wird bei einer Client-/Serververbindung von Clients zum Starten eines asynchronen Vorgangs zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und die Channelbindung verwendet. Diese Methode wird nicht blockiert.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)

Wird bei einer Client-/Serververbindung von Clients zum Starten eines asynchronen Vorgangs zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen verwendet. Diese Methode wird nicht blockiert.

BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Wird bei einer Client-/Serververbindung von Clients zum Starten eines asynchronen Vorgangs zum Authentifizieren des Clients und optional auch des Servers aufgerufen. Beim Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und Authentifizierungsoptionen verwendet. Diese Methode wird nicht blockiert.

BeginAuthenticateAsServer(AsyncCallback, Object)

Wird bei einer Client-/Serververbindungen von Servern zum Starten eines asynchronen Vorgangs zur Authentifizierung des Clients und optional auch des Servers aufgerufen. Diese Methode wird nicht blockiert.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)

Wird bei einer Client-/Serververbindungen von Servern zum Starten eines asynchronen Vorgangs zur Authentifizierung des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess wird die angegebene erweiterte Schutzrichtlinie verwendet. Diese Methode wird nicht blockiert.

BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Wird bei einer Client-/Serververbindungen von Servern zum Starten eines asynchronen Vorgangs zur Authentifizierung des Clients und optional auch des Servers aufgerufen. Für den Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und die erweiterte Schutzrichtlinie verwendet. Diese Methode wird nicht blockiert.

BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)

Wird bei einer Client-/Serververbindungen von Servern zum Starten eines asynchronen Vorgangs zur Authentifizierung des Clients und optional auch des Servers aufgerufen. Beim Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen und die angegebenen Authentifizierungsoptionen verwendet. Diese Methode wird nicht blockiert.

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Startet einen asynchronen Lesevorgang, der Daten aus dem Stream liest und im angegebenen Array speichert.

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Lesevorgang. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).)

(Geerbt von Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Startet einen asynchronen Schreibvorgang, der Byte vom angegebenen Puffer in den Stream schreibt.

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Beginnt einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).)

(Geerbt von Stream)
Close()

Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles). Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird.

(Geerbt von Stream)
CopyTo(Stream)

Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom. Beide Datenströme werden durch die Anzahl der kopierten Bytes erweitert.

(Geerbt von Stream)
CopyTo(Stream, Int32)

Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom. Beide Datenströme werden durch die Anzahl der kopierten Bytes erweitert.

(Geerbt von Stream)
CopyToAsync(Stream)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream. Beide Datenströme werden durch die Anzahl der kopierten Bytes erweitert.

(Geerbt von Stream)
CopyToAsync(Stream, CancellationToken)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung eines angegebenen Abbruchtokens in einen anderen Stream. Beide Datenströme werden durch die Anzahl der kopierten Bytes erweitert.

(Geerbt von Stream)
CopyToAsync(Stream, Int32)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream. Beide Datenströme werden durch die Anzahl der kopierten Bytes erweitert.

(Geerbt von Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße und eines Abbruchtokens in einen anderen Stream. Beide Datenströme werden durch die Anzahl der kopierten Bytes erweitert.

(Geerbt von Stream)
CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
CreateWaitHandle()
Veraltet.
Veraltet.
Veraltet.

Reserviert ein WaitHandle-Objekt.

(Geerbt von Stream)
Dispose()

Gibt alle vom Stream verwendeten Ressourcen frei.

(Geerbt von Stream)
Dispose(Boolean)

Gibt die von NegotiateStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

Dispose(Boolean)

Gibt die von AuthenticatedStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.

(Geerbt von AuthenticatedStream)
DisposeAsync()

Gibt die nicht verwalteten und verwalteten Ressourcen, die von NegotiateStream verwendet werden, asynchron frei.

DisposeAsync()

Gibt die nicht verwalteten und verwalteten Ressourcen, die von AuthenticatedStream verwendet werden, asynchron frei.

(Geerbt von AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem Aufruf von BeginAuthenticateAsClient gestartet wurde.

EndAuthenticateAsServer(IAsyncResult)

Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem Aufruf von BeginAuthenticateAsServer gestartet wurde.

EndRead(IAsyncResult)

Beendet einen asynchronen Lesevorgang, der mit einem Aufruf von BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) gestartet wurde.

EndRead(IAsyncResult)

Wartet, bis der ausstehende asynchrone Lesevorgang abgeschlossen ist. (Verwenden Sie stattdessen ReadAsync(Byte[], Int32, Int32).)

(Geerbt von Stream)
EndWrite(IAsyncResult)

Beendet einen asynchronen Schreibvorgang, der mit einem Aufruf von BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) gestartet wurde.

EndWrite(IAsyncResult)

Beendet einen asynchronen Schreibvorgang. (Verwenden Sie stattdessen WriteAsync(Byte[], Int32, Int32).)

(Geerbt von Stream)
Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
Flush()

Veranlasst das Schreiben aller gepufferten Daten in das zugrunde liegende Gerät.

FlushAsync()

Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät.

(Geerbt von Stream)
FlushAsync(CancellationToken)

Schreibt asynchron alle gepufferten Daten auf das zugrunde liegende Gerät.

FlushAsync(CancellationToken)

Löscht alle Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät und überwacht Abbruchanforderungen.

(Geerbt von Stream)
GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.

(Geerbt von MarshalByRefObject)
ObjectInvariant()
Veraltet.

Bietet Unterstützung für einen Contract.

(Geerbt von Stream)
Read(Byte[], Int32, Int32)

Liest Daten aus diesem Stream und speichert sie im angegebenen Array.

Read(Span<Byte>)

Liest beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes aus dem aktuellen Stream und erhöht die Position im Stream um die Anzahl der gelesenen Bytes.

(Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32)

Liest eine Bytesequenz asynchron aus dem aktuellen Stream und setzt die Position in diesem Stream um die Anzahl der gelesenen Bytes nach vorn.

(Geerbt von Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Liest Daten asynchron aus diesem Stream und speichert sie im angegebenen Array.

ReadAsync(Byte[], Int32, Int32, CancellationToken)

Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen.

(Geerbt von Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Liest Daten asynchron aus dem NegotiateStream und speichert sie als asynchronen Vorgang in einem Bytespeicherbereich.

ReadAsync(Memory<Byte>, CancellationToken)

Liest eine Folge von Bytes asynchron aus aktuellen Stream, erhöht die Position im Stream um die Anzahl der gelesenen Bytes und überwacht Abbruchanfragen.

(Geerbt von Stream)
ReadAtLeast(Span<Byte>, Int32, Boolean) (Geerbt von Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) (Geerbt von Stream)
ReadByte()

Liest ein Byte aus dem Stream und erhöht die Position im Stream um ein Byte, oder gibt -1 zurück, wenn das Ende des Streams erreicht ist.

(Geerbt von Stream)
ReadExactly(Byte[], Int32, Int32) (Geerbt von Stream)
ReadExactly(Span<Byte>) (Geerbt von Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) (Geerbt von Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken) (Geerbt von Stream)
Seek(Int64, SeekOrigin)

Löst NotSupportedException aus.

SetLength(Int64)

Legt die Länge des zugrunde liegenden Streams fest.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
Write(Byte[], Int32, Int32)

Schreiben Sie die angegebene Anzahl von Byte mit dem angegebenen Puffer und dem angegebenen Offset in den zugrunde liegenden Stream.

Write(ReadOnlySpan<Byte>)

Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes.

(Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32)

Schreibt eine Bytesequenz asynchron in den aktuellen Stream und setzt die aktuelle Position in diesem Stream um die Anzahl der geschriebenen Bytes nach vorn.

(Geerbt von Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Die angegebene Byte-Anzahl wird asynchron in den zugrunde liegenden Stream geschrieben.

WriteAsync(Byte[], Int32, Int32, CancellationToken)

Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.

(Geerbt von Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Die angegebene Byte-Anzahl wird asynchron in den zugrunde liegenden Stream geschrieben.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Schreibt beim Überschreiben in einer abgeleiteten Klasse eine Folge von Bytes asynchron in den aktuellen Stream und erhöht die aktuelle Position im Stream um die Anzahl der geschriebenen Bytes und überwacht Abbruchanforderungen.

(Geerbt von Stream)
WriteByte(Byte)

Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte.

(Geerbt von Stream)

Erweiterungsmethoden

ConfigureAwait(IAsyncDisposable, Boolean)

Konfiguriert, wie Wartezeiten auf die Aufgaben angewandt werden, die von einem asynchronen verwerfbaren Element zurückgegeben werden.

Gilt für:

Siehe auch