NegotiateStream NegotiateStream NegotiateStream NegotiateStream Class

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.Provides a stream that uses the Negotiate security protocol to authenticate the client, and optionally the server, in client-server communication.

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
Vererbung

Beispiele

Im folgenden Beispiel wird die Clientseite einer Client/Server-Verbindung veranschaulicht, die NegotiateStreamverwendet.The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. Der Client authentifiziert eine Nachricht und sendet sie asynchron an den Server.The client authenticates and sends a message to the server asynchronously.

#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.
            IAsyncResult ar = authStream.BeginAuthenticateAsClient(
                new AsyncCallback(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.
            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
            ar = authStream.BeginWrite(message, 0, message.Length,
                new AsyncCallback(EndWriteCallback),
                authStream);
            ar.AsyncWaitHandle.WaitOne();
            Console.WriteLine("Sent {0} bytes.", message.Length);
            // Close the client connection.
            authStream.Close();
            Console.WriteLine("Client closed.");
        }
        // The following method is called when the authentication completes.
        public static void EndAuthenticateCallback (IAsyncResult ar)
        {
            Console.WriteLine("Client ending authentication...");
            NegotiateStream authStream = (NegotiateStream) ar.AsyncState;
            Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);

            // End the asynchronous operation.
            authStream.EndAuthenticateAsClient(ar);
        }
        // The following method is called when the write operation completes.
        public static void EndWriteCallback (IAsyncResult ar)
        {
            Console.WriteLine("Client ending write operation...");
            NegotiateStream authStream = (NegotiateStream) ar.AsyncState;

            // End the asynchronous operation.
            authStream.EndWrite(ar);
        }
    }

    // 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 Client/Server-Verbindung veranschaulicht, die NegotiateStream die zum Authentifizieren des Clients und zum Lesen einer vom Client gesendeten Nachricht verwendet.The following code example demonstrates the server side of a client-server connection that uses the NegotiateStream to authenticate the client and read a message sent by the 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 = null;
                // 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);
                    continue;
                }

            }
        
        }
        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.
            authStream.BeginAuthenticateAsServer (
                new AsyncCallback(EndAuthenticateCallback),
                cState
                );
            // Wait until the authentication completes.
            cState.Waiter.WaitOne();
            cState.Waiter.Reset();
            authStream.BeginRead(cState.Buffer, 0, cState.Buffer.Length, 
                   new AsyncCallback(EndReadCallback), 
                   cState);
            cState.Waiter.WaitOne();
            // Finished with the current client.
            authStream.Close();
            clientRequest.Close();
        }
        // The following method is invoked by the
        // BeginAuthenticateAsServer callback delegate.

        public static void EndAuthenticateCallback (IAsyncResult ar)
        {
            // Get the saved data.
            ClientState cState = (ClientState) ar.AsyncState;
            TcpClient clientRequest = cState.Client;
            NegotiateStream authStream = (NegotiateStream) cState.AuthenticatedStream;
            Console.WriteLine("Ending authentication.");
            // Any exceptions that occurred during authentication are
            // thrown by the EndAuthenticateAsServer method.
            try 
            {
                // This call blocks until the authentication is complete.
                authStream.EndAuthenticateAsServer(ar);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Authentication failed - closing connection.");
                cState.Waiter.Set();
                return;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Closing connection.");
                cState.Waiter.Set();
                return;
            }
            // Display properties of the authenticated client.
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} was authenticated using {1}.", 
                id.Name, 
                id.AuthenticationType
                );
            cState.Waiter.Set();

    }
        public static void EndReadCallback(IAsyncResult ar)
        {
            // Get the saved data.
            ClientState cState = (ClientState) ar.AsyncState;
            TcpClient clientRequest = cState.Client;
            NegotiateStream authStream = (NegotiateStream) cState.AuthenticatedStream; 
            // 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, 
                               new AsyncCallback(EndReadCallback), 
                               cState);
                               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);
                cState.Waiter.Set();
                return;
            }
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString());
            cState.Waiter.Set();
        }
    }
    // ClientState is the AsyncState object.
    internal class ClientState
    {
        private AuthenticatedStream authStream = null;
        private  TcpClient client = null;
        byte[] buffer = new byte[2048];
        StringBuilder message = null;
        ManualResetEvent waiter = new ManualResetEvent(false);
        internal ClientState(AuthenticatedStream a, TcpClient theClient)
        {
            authStream = a;
            client = theClient;
        }
        internal TcpClient Client
        { 
            get { return client;}
        }
        internal AuthenticatedStream AuthenticatedStream
        {
            get { return authStream;}
        }
        internal byte[] Buffer
        {
              get { return buffer;}
        }
        internal StringBuilder Message
        {
            get 
            { 
                if (message == null)
                    message = new StringBuilder();
                return message;
             }
        }
        internal ManualResetEvent Waiter
        {
            get 
            { 
                return waiter;
             }
        }
    }
}

Hinweise

Verwenden Sie NegotiateStream die-Klasse für die Authentifizierung und zum Sichern von Informationen, die zwischen einem Client und einem Server übertragen werden.Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. Mithilfe NegotiateStreamvon können Sie die folgenden Aktionen ausführen.Using NegotiateStream, you can do the following.

  • Senden Sie die Anmelde Informationen des Clients für Identitätswechsel oder Delegierung an den-Server.Send the client's credentials to the server for Impersonation or Delegation.

  • Anfordern der Server Authentifizierung.Request server authentication.

  • Verschlüsseln und/oder Signieren von Daten vor der Übertragung.Encrypt and/or sign data before transmitting it.

Vor dem Übertragen von Informationen muss die Authentifizierung erfolgen.Authentication must be performed before transmitting information. Clients fordern die Authentifizierung mithilfe der AuthenticateAsClient synchronen Methoden an, die blockieren, bis die Authentifizierung abgeschlossen ist, BeginAuthenticateAsClient oder der asynchronen Methoden, die nicht blockiert werden, während auf den Abschluss der Authentifizierung gewartet wird.Clients request authentication using the synchronous AuthenticateAsClient methods, which block until the authentication completes, or the asynchronous BeginAuthenticateAsClient methods, which do not block while waiting for the authentication to complete. Server fordern die Authentifizierung mithilfe der AuthenticateAsServer synchronen oder asynchronen BeginAuthenticateAsServer Methoden an.Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Der Client und optional der Server werden mithilfe des Aushandlungs Sicherheitsprotokolls authentifiziert.The client, and optionally the server, is authenticated using the Negotiate security protocol. Auf Windows 95/98-Systemen wird Windows NT LAN Manager (NTLM) als Protokoll für die Authentifizierung verwendet.On Windows 95/98 systems, Windows NT LAN Manager (NTLM) is the protocol used for authentication. Auf anderen Plattformen wird das Kerberos-Protokoll für die Authentifizierung verwendet, wenn sowohl der Client als auch der Server dies unterstützen. Andernfalls wird NTLM verwendet.On other platforms the Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. Ausführliche Beschreibungen dieser Protokolle finden Sie in der Platform SDK-Dokumentation auf MSDN unter msdn.Microsoft.com/library/.For detailed descriptions of these protocols, see the Platform SDK documentation on MSDN, at msdn.microsoft.com/library/. Die NegotiateStream -Klasse führt die Authentifizierung mithilfe der Security Support Provider-Schnittstelle (SSPI) aus.The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

Wenn die Authentifizierung erfolgreich ist, müssen Sie IsEncrypted die IsSigned -Eigenschaft und die-Eigenschaft überprüfen, um zu NegotiateStream bestimmen, welche Sicherheitsdienste vom verwendet werden, um die Daten während der Übertragung zu schützenWhen authentication succeeds, you must check the IsEncrypted and IsSigned properties to determine what security services will be used by the NegotiateStream to help secure your data during transmission. Überprüfen IsMutuallyAuthenticated Sie die-Eigenschaft, um zu bestimmen, ob die gegenseitigeCheck the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. Mithilfe der RemoteIdentity -Eigenschaft können Sie Informationen zum Remote Client oder-Server erhalten.You can get information about the remote client or server using the RemoteIdentity property.

Wenn bei der Authentifizierung ein Fehler auftritt, wird AuthenticationException ein oder InvalidCredentialExceptionein empfangen.If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. In diesem Fall können Sie die Authentifizierung mit anderen Anmelde Informationen wiederholen.In this case, you can retry the authentication with a different credential.

Sie senden Daten mithilfe der synchronen Write oder asynchronen BeginWrite Methoden.You send data using the synchronous Write or asynchronous BeginWrite methods. Sie empfangen Daten mithilfe der synchronen Read oder asynchronen BeginRead Methoden.You receive data using the synchronous Read or asynchronous BeginRead methods. Wenn Sicherheitsdienste wie z. b. Verschlüsselung oder Signierung aktiviert sind, werden diese durch die automatisch NegotiateStreamauf die Daten angewendet.If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

Der NegotiateStream überträgt Daten mithilfe eines Datenstroms, den Sie beim Erstellen NegotiateStreamdes bereitstellen.The NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. Wenn Sie diesen zugrunde liegenden Stream bereitstellen, haben Sie die Möglichkeit anzugeben, ob NegotiateStream durch das Schließen von auch der zugrunde liegende Stream geschlossen wird.When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

Konstruktoren

NegotiateStream(Stream) NegotiateStream(Stream) NegotiateStream(Stream) NegotiateStream(Stream)

Initialisiert eine neue Instanz der NegotiateStream-Klasse mit dem angegebenen Stream.Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean) NegotiateStream(Stream, Boolean) NegotiateStream(Stream, Boolean) NegotiateStream(Stream, Boolean)

Verwendet den angegebenen NegotiateStream und das Schlussverhalten des Streams zum Initialisieren einer neuen Instanz der Stream-Klasse.Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

Eigenschaften

CanRead CanRead CanRead CanRead

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream gelesen werden kann.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek CanSeek CanSeek CanSeek

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream durchsucht werden kann.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout CanTimeout CanTimeout CanTimeout

Ruft einen Boolean-Wert ab, der angibt, ob der zugrunde liegende Stream Timeouts unterstützt.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite CanWrite CanWrite CanWrite

Ruft einen Boolean-Wert ab, der angibt, ob im zugrunde liegenden Stream geschrieben werden kann.Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel ImpersonationLevel ImpersonationLevel ImpersonationLevel

Ruft einen Wert ab, der angibt, wie der Server die Clientanmeldeinformationen verwenden kann.Gets a value that indicates how the server can use the client's credentials.

InnerStream InnerStream InnerStream InnerStream

Ruft den von diesem AuthenticatedStream verwendeten Stream zum Senden und Empfangen von Daten ab.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Inherited from AuthenticatedStream)
IsAuthenticated IsAuthenticated IsAuthenticated IsAuthenticated

Ruft einen Boolean-Wert ab, der angibt, ob die Authentifizierung erfolgreich war.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted IsEncrypted IsEncrypted IsEncrypted

Ruft einen Boolean-Wert ab, der angibt, ob dieser NegotiateStream verschlüsselte Daten verwendet.Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated IsMutuallyAuthenticated IsMutuallyAuthenticated IsMutuallyAuthenticated

Ruft einen Boolean-Wert ab, der angibt, ob sowohl der Server als auch der Client authentifiziert wurden.Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer IsServer IsServer IsServer

Ruft einen Boolean-Wert ab, der angibt, ob die lokale, von diesem NegotiateStream verwendete Seite der Verbindung als Server authentifiziert wurde.Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned IsSigned IsSigned IsSigned

Ruft einen Boolean-Wert ab, der angibt, ob die mit diesem Stream gesendeten Daten signiert sind.Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen LeaveInnerStreamOpen LeaveInnerStreamOpen LeaveInnerStreamOpen

Ruft ab, ob der zum Senden und Empfangen von Daten von diesem AuthenticatedStream verwendete Stream weiterhin geöffnet ist.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Inherited from AuthenticatedStream)
Length Length Length Length

Ruft die Länge des zugrunde liegenden Streams ab.Gets the length of the underlying stream.

Position Position Position Position

Ruft die aktuelle Position im zugrunde liegenden Stream ab oder legt diese fest.Gets or sets the current position in the underlying stream.

ReadTimeout ReadTimeout ReadTimeout ReadTimeout

Ruft die Zeitspanne ab, in der ein Lesevorgang während des Wartens auf Daten blockiert wird, oder legt diese fest.Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity RemoteIdentity RemoteIdentity RemoteIdentity

Ruft Informationen zur Identität der Remoteseite ab, für die dieser authentifizierte Stream freigegeben ist.Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout WriteTimeout WriteTimeout WriteTimeout

Ruft die Zeitspanne ab, in der ein Schreibvorgang während des Wartens auf Daten blockiert wird, oder legt diese fest.Gets or sets the amount of time a write operation blocks waiting for data.

Methoden

AuthenticateAsClient() AuthenticateAsClient() AuthenticateAsClient() AuthenticateAsClient()

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String) AuthenticateAsClient(NetworkCredential, ChannelBinding, String) AuthenticateAsClient(NetworkCredential, ChannelBinding, String) AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen und die Channelbindung verwendet.The authentication process uses the specified client credential and the channel binding.

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

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und die Channelbindung verwendet.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String) AuthenticateAsClient(NetworkCredential, String) AuthenticateAsClient(NetworkCredential, String) AuthenticateAsClient(NetworkCredential, String)

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen verwendet.The authentication process uses the specified client credential.

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

Wird bei einer Client-/Serververbindung von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Beim Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und Authentifizierungsoptionen verwendet.The authentication process uses the specified credentials and authentication options.

AuthenticateAsClientAsync() AuthenticateAsClientAsync() AuthenticateAsClientAsync() AuthenticateAsClientAsync()

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String) AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String) AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String) 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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen und die Channelbindung verwendet.The authentication process uses the specified client credential and the channel binding.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) 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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und die Channelbindung verwendet.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClientAsync(NetworkCredential, String) AuthenticateAsClientAsync(NetworkCredential, String) AuthenticateAsClientAsync(NetworkCredential, String) AuthenticateAsClientAsync(NetworkCredential, String)

Wird von Clients zum Authentifizieren des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindung als asynchroner Vorgang aufgerufen.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Für den Authentifizierungsprozess werden die angegebenen Clientanmeldeinformationen verwendet.The authentication process uses the specified client credential.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) 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.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Beim Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und Authentifizierungsoptionen verwendet.The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer() AuthenticateAsServer() AuthenticateAsServer() AuthenticateAsServer()

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy) AuthenticateAsServer(ExtendedProtectionPolicy) AuthenticateAsServer(ExtendedProtectionPolicy) AuthenticateAsServer(ExtendedProtectionPolicy)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess wird die angegebene erweiterte Schutzrichtlinie verwendet.The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und die erweiterte Schutzrichtlinie verwendet.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Wird bei einer Client-/Serververbindung von Servern zum Authentifizieren des Clients und optional auch des Servers aufgerufen.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Beim Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen und die angegebenen Authentifizierungsoptionen verwendet.The authentication process uses the specified server credentials and authentication options.

AuthenticateAsServerAsync() AuthenticateAsServerAsync() AuthenticateAsServerAsync() AuthenticateAsServerAsync()

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsServerAsync(ExtendedProtectionPolicy) AuthenticateAsServerAsync(ExtendedProtectionPolicy) AuthenticateAsServerAsync(ExtendedProtectionPolicy) AuthenticateAsServerAsync(ExtendedProtectionPolicy)

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Für den Authentifizierungsprozess wird die angegebene erweiterte Schutzrichtlinie verwendet.The authentication process uses the specified extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) 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.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Für den Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und die erweiterte Schutzrichtlinie verwendet.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Wird von Servern zur Authentifizierung des Clients und optional auch des Servers aufgerufen, bei einer Client-/Serververbindungen als asynchroner Vorgang.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Beim Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen und die angegebenen Authentifizierungsoptionen verwendet.The authentication process uses the specified server credentials and authentication options.

BeginAuthenticateAsClient(AsyncCallback, Object) BeginAuthenticateAsClient(AsyncCallback, Object) BeginAuthenticateAsClient(AsyncCallback, Object) 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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object) 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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und die Channelbindung verwendet.The authentication process uses the specified credentials and channel binding. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) 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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen, Authentifizierungsoptionen und die Channelbindung verwendet.The authentication process uses the specified credentials, authentication options, and channel binding. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object) 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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Anmeldeinformationen verwendet.The authentication process uses the specified credentials. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) 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.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Beim Authentifizierungsprozess werden die angegebenen Anmeldeinformationen und Authentifizierungsoptionen verwendet.The authentication process uses the specified credentials and authentication options. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsServer(AsyncCallback, Object) BeginAuthenticateAsServer(AsyncCallback, Object) BeginAuthenticateAsServer(AsyncCallback, Object) 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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object) BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object) BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object) 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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess wird die angegebene erweiterte Schutzrichtlinie verwendet.The authentication process uses the specified extended protection policy. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) 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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Für den Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen, Authentifizierungsoptionen und die erweiterte Schutzrichtlinie verwendet.The authentication process uses the specified server credentials, authentication options, and extended protection policy. Diese Methode wird nicht blockiert.This method does not block.

BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) 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.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Beim Authentifizierungsprozess werden die angegebenen Serveranmeldeinformationen und die angegebenen Authentifizierungsoptionen verwendet.The authentication process uses the specified server credentials and authentication options. Diese Methode wird nicht blockiert.This method does not block.

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

Startet einen asynchronen Lesevorgang, der Daten aus dem Stream liest und im angegebenen Array speichert.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Startet einen asynchronen Schreibvorgang, der Byte vom angegebenen Puffer in den Stream schreibt.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close() Close() Close() Close()

Schließt den aktuellen Stream und gibt alle dem aktuellen Stream zugeordneten Ressourcen frei (z. B. Sockets und Dateihandles).Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Anstatt diese Methode aufzurufen, stellen Sie sicher, dass der Stream ordnungsgemäß freigegeben wird.Instead of calling this method, ensure that the stream is properly disposed.

(Inherited from Stream)
CopyTo(Stream) CopyTo(Stream) CopyTo(Stream) CopyTo(Stream)

Liest alle Bytes aus dem aktuellen Stream und schreibt sie in einen anderen Datenstrom.Reads the bytes from the current stream and writes them to another stream.

(Inherited from Stream)
CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32) CopyTo(Stream, Int32)

Liest alles Bytes aus dem aktuellen Datenstrom und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Datenstrom.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Inherited from Stream)
CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream) CopyToAsync(Stream)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie in einen anderen Stream.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Inherited from Stream)
CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken) CopyToAsync(Stream, CancellationToken)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung eines angegebenen Abbruchtokens in einen anderen Stream.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Inherited from Stream)
CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32) CopyToAsync(Stream, Int32)

Liest die Bytes asynchron aus dem aktuellen Stream und schreibt sie unter Verwendung einer angegebenen Puffergröße in einen anderen Stream.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Inherited from Stream)
CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) CopyToAsync(Stream, Int32, CancellationToken) 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.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Inherited from Stream)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
CreateWaitHandle() CreateWaitHandle() CreateWaitHandle() CreateWaitHandle()

Reserviert ein WaitHandle-Objekt.Allocates a WaitHandle object.

(Inherited from Stream)
Dispose() Dispose() Dispose() Dispose()

Gibt alle vom Stream verwendeten Ressourcen frei.Releases all resources used by the Stream.

(Inherited from Stream)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Gibt die von NegotiateStream verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

DisposeAsync() DisposeAsync() DisposeAsync() DisposeAsync()

Gibt die nicht verwalteten und verwalteten Ressourcen, die von NegotiateStream verwendet werden, asynchron frei.Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult) EndAuthenticateAsClient(IAsyncResult)

Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem Aufruf von BeginAuthenticateAsClient gestartet wurde.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult) EndAuthenticateAsServer(IAsyncResult)

Beendet einen ausstehenden asynchronen Clientauthentifizierungsvorgang, der mit einem Aufruf von BeginAuthenticateAsServer gestartet wurde.Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult) EndRead(IAsyncResult)

Beendet einen asynchronen Lesevorgang, der mit einem Aufruf von BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) gestartet wurde.Ends an asynchronous read operation that was started with a call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult) EndWrite(IAsyncResult) EndWrite(IAsyncResult) EndWrite(IAsyncResult)

Beendet einen asynchronen Schreibvorgang, der mit einem Aufruf von BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) gestartet wurde.Ends an asynchronous write operation that was started with a call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Flush() Flush() Flush() Flush()

Veranlasst das Schreiben aller gepufferten Daten in das zugrunde liegende Gerät.Causes any buffered data to be written to the underlying device.

FlushAsync() FlushAsync() FlushAsync() FlushAsync()

Löscht sämtliche Puffer für diesen Stream asynchron und veranlasst die Ausgabe aller gepufferten Daten an das zugrunde liegende Gerät.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Inherited from Stream)
FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken) FlushAsync(CancellationToken)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als Standardhashfunktion.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ObjectInvariant() ObjectInvariant() ObjectInvariant() ObjectInvariant()

Bietet Unterstützung für einen Contract.Provides support for a Contract.

(Inherited from Stream)
Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32) Read(Byte[], Int32, Int32)

Liest Daten aus diesem Stream und speichert sie im angegebenen Array.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>) Read(Span<Byte>) Read(Span<Byte>) 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.When overridden in a derived class, reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Inherited from Stream)
ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) ReadAsync(Byte[], Int32, Int32) 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.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Inherited from Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) ReadAsync(Byte[], Int32, Int32, CancellationToken) 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.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Inherited from Stream)
ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) ReadAsync(Memory<Byte>, CancellationToken) 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.Asynchronously reads a sequence of bytes from the current stream, advances the position within the stream by the number of bytes read, and monitors cancellation requests.

(Inherited from Stream)
ReadByte() ReadByte() ReadByte() 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.Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.

(Inherited from Stream)
Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin) Seek(Int64, SeekOrigin)

Löst NotSupportedException aus.Throws NotSupportedException.

SetLength(Int64) SetLength(Int64) SetLength(Int64) SetLength(Int64)

Legt die Länge des zugrunde liegenden Streams fest.Sets the length of the underlying stream.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)
Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) Write(Byte[], Int32, Int32) 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 the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) Write(ReadOnlySpan<Byte>) 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.When overridden in a derived class, writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Inherited from Stream)
WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) WriteAsync(Byte[], Int32, Int32) 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.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Inherited from Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) WriteAsync(Byte[], Int32, Int32, CancellationToken) 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.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Inherited from Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) 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.Asynchronously writes a sequence of bytes to the current stream, advances the current position within this stream by the number of bytes written, and monitors cancellation requests.

(Inherited from Stream)
WriteByte(Byte) WriteByte(Byte) WriteByte(Byte) WriteByte(Byte)

Schreibt ein Byte an die aktuellen Position im Stream und erhöht die aktuelle Position im Stream um ein Byte.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Inherited from Stream)

Explizite Schnittstellenimplementierungen

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

Gibt alle vom Stream verwendeten Ressourcen frei.Releases all resources used by the Stream.

(Inherited from Stream)

Gilt für:

Siehe auch