NegotiateStream Klasse
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
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::AuthenticatedStreampublic class NegotiateStream : System.Net.Security.AuthenticatedStream[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public class NegotiateStream : System.Net.Security.AuthenticatedStreamtype NegotiateStream = class
inherit AuthenticatedStream[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
type NegotiateStream = class
inherit AuthenticatedStreamPublic Class NegotiateStream
Inherits AuthenticatedStream- Vererbung
- Vererbung
- Attribute
Beispiele
Im folgenden Beispiel wird die Clientseite einer Client-Server-Verbindung veranschaulicht, die den NegotiateStreamverwendet. Der Client authentifiziert sich und sendet eine Nachricht asynchron 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
Das folgende Codebeispiel veranschaulicht die Serverseite einer Client-Server-Verbindung, die verwendet, NegotiateStream um den Client zu authentifizieren und eine vom Client gesendete Nachricht zu 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 zum Schützen von Informationen, die zwischen einem Client und einem Server übertragen werden. Mit NegotiateStreamkönnen Sie die folgenden Schritte ausführen.
Senden Sie die Anmeldeinformationen des Clients an den Server für Identitätswechsel oder Delegierung.
Anforderungsserverauthentifizierung.
Verschlüsseln und/oder signieren Sie Daten vor der Übertragung.
Die Authentifizierung muss vor der Übermittlung von Informationen erfolgen. Clients fordern die Authentifizierung mithilfe der synchronen AuthenticateAsClient Methoden an, die blockiert werden, bis die Authentifizierung abgeschlossen ist, oder die asynchronen BeginAuthenticateAsClient Methoden, die während des Wartens 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 Negotiate-Sicherheitsprotokolls authentifiziert. Das Kerberos-Protokoll wird für die Authentifizierung verwendet, wenn es sowohl vom Client als auch vom Server unterstützt wird. andernfalls wird NTLM verwendet. Die NegotiateStream -Klasse führt die Authentifizierung mithilfe der Security Support Provider Interface (SSPI) aus.
Wenn die Authentifizierung erfolgreich ist, müssen Sie die IsEncrypted Eigenschaften und IsSigned überprüfen, um zu ermitteln, welche Sicherheitsdienste von verwendet werden, um Ihre Daten während der NegotiateStream Übertragung zu schützen. Überprüfen Sie die IsMutuallyAuthenticated -Eigenschaft, um festzustellen, ob die gegenseitige Authentifizierung stattgefunden hat. Mithilfe der -Eigenschaft können Sie Informationen zum Remoteclient oder -server RemoteIdentity abrufen.
Wenn bei der Authentifizierung ein Fehler auftritt, erhalten Sie ein AuthenticationException oder ein InvalidCredentialException. In diesem Fall können Sie die Authentifizierung mit anderen Anmeldeinformationen wiederholen.
Sie senden Daten mit synchronen Write oder asynchronen BeginWrite Methoden oder WriteAsync . Sie erhalten Daten mithilfe der synchronen Read oder asynchronen ReadAsync Oder-Methoden BeginRead . Wenn Sicherheitsdienste wie Verschlüsselung oder Signatur aktiviert sind, werden diese automatisch von NegotiateStreamauf Ihre Daten angewendet.
Der NegotiateStream überträgt Daten mithilfe eines Datenstroms, den Sie beim Erstellen von NegotiateStreamangeben. Wenn Sie diesen zugrunde liegenden Stream bereitstellen, können Sie angeben, ob das Schließen des NegotiateStream auch den zugrunde liegenden Stream schließt.
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 Streamspositionen werden um 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 Streamspositionen werden um 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 Streamspositionen werden um 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 Streamspositionen werden um 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 Streamspositionen werden um 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 Streamspositionen werden um 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 alle gepufferten Daten asynchron 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) |
Liest mindestens eine Mindestanzahl von Bytes aus dem aktuellen Stream und erhöht die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes. (Geerbt von Stream) |
| ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) |
Liest asynchron mindestens eine Mindestanzahl von Bytes aus dem aktuellen Stream, erhöht die Position innerhalb des Datenstroms um die Anzahl der gelesenen Bytes und überwacht Abbruchanforderungen. (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) |
Liest |
| ReadExactly(Span<Byte>) |
Liest Bytes aus dem aktuellen Stream und erhöht die Position innerhalb des Datenstroms, bis der |
| ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) |
Liest |
| ReadExactlyAsync(Memory<Byte>, CancellationToken) |
Liest Bytes asynchron aus dem aktuellen Stream, erhöht die Position im Stream, bis der |
| 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:
Weitere Informationen
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für