NegotiateStream Klasa
Definicja
Ważne
Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Udostępnia strumień, który używa protokołu zabezpieczeń Negotiate do uwierzytelniania klienta i opcjonalnie serwera w komunikacji klient-serwer.
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- Dziedziczenie
- Dziedziczenie
- Atrybuty
Przykłady
W poniższym przykładzie pokazano stronę klienta połączenia klient-serwer, które korzysta z programu NegotiateStream. Klient uwierzytelnia się i wysyła komunikat do serwera asynchronicznie.
#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
W poniższym przykładzie kodu pokazano po stronie serwera połączenie klient-serwer, które używa parametru NegotiateStream do uwierzytelniania klienta i odczytywania komunikatu wysłanego przez klienta.
#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(); }
}
}
}
Uwagi
NegotiateStream Użyj klasy na potrzeby uwierzytelniania i w celu zabezpieczenia informacji przesyłanych między klientem a serwerem. Przy użyciu polecenia NegotiateStreammożna wykonać następujące czynności.
Wyślij poświadczenia klienta do serwera w celu personifikacji lub delegowania.
Żądanie uwierzytelniania serwera.
Szyfruj i/lub podpisz dane przed ich przesłaniem.
Przed przesłaniem informacji należy przeprowadzić uwierzytelnianie. Klienci żądają uwierzytelniania przy użyciu metod synchronicznych AuthenticateAsClient , które blokują do momentu ukończenia uwierzytelniania lub metod asynchronicznych BeginAuthenticateAsClient , które nie blokują podczas oczekiwania na ukończenie uwierzytelniania. Serwery żądają uwierzytelniania przy użyciu metod synchronicznych AuthenticateAsServer lub asynchronicznych BeginAuthenticateAsServer . Klient i opcjonalnie serwer jest uwierzytelniany przy użyciu protokołu zabezpieczeń Negotiate. Protokół Kerberos jest używany do uwierzytelniania, jeśli klient i serwer go obsługują; w przeciwnym razie jest używany protokół NTLM. Klasa NegotiateStream wykonuje uwierzytelnianie przy użyciu interfejsu dostawcy obsługi zabezpieczeń (SSPI).
Po pomyślnym uwierzytelnieniu należy sprawdzić IsEncrypted właściwości i IsSigned , aby określić, które usługi zabezpieczeń będą używane przez usługę NegotiateStream , aby ułatwić zabezpieczanie danych podczas transmisji. Sprawdź właściwość , IsMutuallyAuthenticated aby określić, czy wystąpiło wzajemne uwierzytelnianie. Informacje o zdalnym kliencie lub serwerze można uzyskać przy użyciu RemoteIdentity właściwości .
Jeśli uwierzytelnianie zakończy się niepowodzeniem, otrzymasz wartość AuthenticationException lub InvalidCredentialException. W takim przypadku można ponowić próbę uwierzytelnienia przy użyciu innego poświadczenia.
Dane są wysyłane przy użyciu metod synchronicznych Write lub asynchronicznych BeginWrite lub WriteAsync . Dane są odbierane przy użyciu metod synchronicznych Read lub asynchronicznych ReadAsync lub BeginRead . Jeśli usługi zabezpieczeń, takie jak szyfrowanie lub podpisywanie, są włączone, są one automatycznie stosowane do danych przez usługę NegotiateStream.
Element NegotiateStream przesyła dane przy użyciu strumienia, który należy podać podczas tworzenia obiektu NegotiateStream. Po podaniu tego bazowego strumienia można określić, czy zamknięcie NegotiateStream również zamyka bazowego strumienia.
Konstruktory
| NegotiateStream(Stream) |
Inicjuje NegotiateStream nowe wystąpienie klasy przy użyciu określonego Streamelementu . |
| NegotiateStream(Stream, Boolean) |
Inicjuje NegotiateStream nowe wystąpienie klasy przy użyciu określonego zachowania zamknięcia strumienia i określonego Stream . |
Właściwości
| CanRead |
Pobiera wartość wskazującą Boolean , czy bazowy strumień jest czytelny. |
| CanSeek |
Pobiera wartość wskazującą Boolean , czy bazowy strumień można wyszukiwać. |
| CanTimeout |
Pobiera wartość wskazującą Boolean , czy bazowy strumień obsługuje limity czasu. |
| CanWrite |
Pobiera wartość wskazującą Boolean , czy źródłowy strumień jest zapisywalny. |
| ImpersonationLevel |
Pobiera wartość wskazującą, jak serwer może używać poświadczeń klienta. |
| InnerStream |
Pobiera strumień używany przez to AuthenticatedStream do wysyłania i odbierania danych. (Odziedziczone po AuthenticatedStream) |
| IsAuthenticated |
Pobiera wartość wskazującą Boolean , czy uwierzytelnianie zakończyło się pomyślnie. |
| IsEncrypted |
Pobiera wartość wskazującą Boolean , czy używa to NegotiateStream szyfrowania danych. |
| IsMutuallyAuthenticated |
Pobiera wartość wskazującą Boolean , czy zarówno serwer, jak i klient zostały uwierzytelnione. |
| IsServer |
Pobiera wartość wskazującą Boolean , czy lokalna strona połączenia używanego przez to NegotiateStream zostało uwierzytelnione jako serwer. |
| IsSigned |
Pobiera wartość wskazującą Boolean , czy dane wysyłane przy użyciu tego strumienia są podpisane. |
| LeaveInnerStreamOpen |
Pobiera informację, czy strumień używany przez tę AuthenticatedStream funkcję do wysyłania i odbierania danych został otwarty. (Odziedziczone po AuthenticatedStream) |
| Length |
Pobiera długość bazowego strumienia. |
| Position |
Pobiera lub ustawia bieżące położenie w strumieniu bazowym. |
| ReadTimeout |
Pobiera lub ustawia czas, przez jaki operacja odczytu blokuje oczekiwanie na dane. |
| RemoteIdentity |
Pobiera informacje o tożsamości strony zdalnej współużytkowania tego uwierzytelnionego strumienia. |
| WriteTimeout |
Pobiera lub ustawia czas, przez jaki operacja zapisu blokuje oczekiwanie na dane. |
Metody
| AuthenticateAsClient() |
Wywoływane przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. |
| AuthenticateAsClient(NetworkCredential, ChannelBinding, String) |
Wywoływane przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń klienta i powiązania kanału. |
| AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta-serwera. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanału. |
| AuthenticateAsClient(NetworkCredential, String) |
Wywoływane przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonego poświadczenia klienta. |
| AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta-serwera. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania. |
| AuthenticateAsClientAsync() |
Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta-serwera jako operacji asynchronicznej. |
| AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String) |
Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta-serwera jako operacji asynchronicznej. Proces uwierzytelniania używa określonego poświadczenia klienta i powiązania kanału. |
| AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanału. |
| AuthenticateAsClientAsync(NetworkCredential, String) |
Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta-serwera jako operacji asynchronicznej. Proces uwierzytelniania używa określonego poświadczenia klienta. |
| AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez klientów w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania. |
| AuthenticateAsServer() |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. |
| AuthenticateAsServer(ExtendedProtectionPolicy) |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej. |
| AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń serwera, opcji uwierzytelniania i zasad rozszerzonej ochrony. |
| AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania. |
| AuthenticateAsServerAsync() |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. |
| AuthenticateAsServerAsync(ExtendedProtectionPolicy) |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej. |
| AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń serwera, opcji uwierzytelniania i zasad rozszerzonej ochrony. |
| AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel) |
Wywoływane przez serwery w celu uwierzytelniania klienta i opcjonalnie serwera w połączeniu klient-serwer jako operacja asynchroniczna. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania. |
| BeginAuthenticateAsClient(AsyncCallback, Object) |
Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Ta metoda nie blokuje. |
| BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object) |
Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń i powiązania kanału. Ta metoda nie blokuje. |
| BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanału. Ta metoda nie blokuje. |
| BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object) |
Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń. Ta metoda nie blokuje. |
| BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Wywoływane przez klientów w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania. Ta metoda nie blokuje. |
| BeginAuthenticateAsServer(AsyncCallback, Object) |
Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Ta metoda nie blokuje. |
| BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object) |
Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej. Ta metoda nie blokuje. |
| BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń serwera, opcji uwierzytelniania i zasad rozszerzonej ochrony. Ta metoda nie blokuje. |
| BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object) |
Wywoływane przez serwery w celu rozpoczęcia operacji asynchronicznej w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klient-serwer. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania. Ta metoda nie blokuje. |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Rozpoczyna asynchroniczną operację odczytu, która odczytuje dane ze strumienia i zapisuje je w określonej tablicy. |
| BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) |
Rozpoczyna asynchroniczną operację odczytu. (Rozważ użycie ReadAsync(Byte[], Int32, Int32) zamiast tego). (Odziedziczone po Stream) |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Rozpoczyna asynchroniczną operację zapisu, która zapisuje Bytes z określonego buforu do strumienia. |
| BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) |
Rozpoczyna asynchroniczną operację zapisu. (Rozważ użycie WriteAsync(Byte[], Int32, Int32) zamiast tego). (Odziedziczone po Stream) |
| Close() |
Zamyka bieżący strumień i zwalnia wszystkie zasoby (takie jak gniazda i dojścia plików) skojarzone z bieżącym strumieniem. Zamiast wywoływać tę metodę, upewnij się, że strumień jest prawidłowo usuwany. (Odziedziczone po Stream) |
| CopyTo(Stream) |
Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu. Oba pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream) |
| CopyTo(Stream, Int32) |
Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu. Oba pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream) |
| CopyToAsync(Stream) |
Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu. Oba pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream) |
| CopyToAsync(Stream, CancellationToken) |
Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego tokenu anulowania. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream) |
| CopyToAsync(Stream, Int32) |
Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream) |
| CopyToAsync(Stream, Int32, CancellationToken) |
Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu i tokenu anulowania. Obie pozycje strumieni są zaawansowane przez liczbę skopiowanych bajtów. (Odziedziczone po Stream) |
| CreateObjRef(Type) |
Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym. (Odziedziczone po MarshalByRefObject) |
| CreateWaitHandle() |
Nieaktualne.
Nieaktualne.
Nieaktualne.
WaitHandle Przydziela obiekt. (Odziedziczone po Stream) |
| Dispose() |
Zwalnia wszelkie zasoby używane przez element Stream. (Odziedziczone po Stream) |
| Dispose(Boolean) |
Zwalnia zasoby niezarządzane używane przez element NegotiateStream i opcjonalnie zwalnia zasoby zarządzane. |
| Dispose(Boolean) |
Zwalnia zasoby niezarządzane używane przez element AuthenticatedStream i opcjonalnie zwalnia zasoby zarządzane. (Odziedziczone po AuthenticatedStream) |
| DisposeAsync() |
Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez NegotiateStreamprogram . |
| DisposeAsync() |
Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez program AuthenticatedStream. (Odziedziczone po AuthenticatedStream) |
| EndAuthenticateAsClient(IAsyncResult) |
Kończy oczekującą operację uwierzytelniania asynchronicznego klienta, która została uruchomiona z wywołaniem metody BeginAuthenticateAsClient. |
| EndAuthenticateAsServer(IAsyncResult) |
Kończy oczekującą operację uwierzytelniania asynchronicznego klienta, która została uruchomiona z wywołaniem metody BeginAuthenticateAsServer. |
| EndRead(IAsyncResult) |
Kończy asynchroniczną operację odczytu, która została uruchomiona z wywołaniem metody BeginRead(Byte[], Int32, Int32, AsyncCallback, Object). |
| EndRead(IAsyncResult) |
Czeka na ukończenie oczekującego odczytu asynchronicznego. (Rozważ użycie ReadAsync(Byte[], Int32, Int32) zamiast tego). (Odziedziczone po Stream) |
| EndWrite(IAsyncResult) |
Kończy asynchroniczną operację zapisu, która została uruchomiona z wywołaniem metody BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object). |
| EndWrite(IAsyncResult) |
Kończy asynchroniczną operację zapisu. (Rozważ użycie WriteAsync(Byte[], Int32, Int32) zamiast tego). (Odziedziczone po Stream) |
| Equals(Object) |
Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object) |
| Flush() |
Powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym. |
| FlushAsync() |
Asynchronicznie czyści wszystkie bufory dla tego strumienia i powoduje zapisanie wszystkich buforowanych danych na urządzeniu bazowym. (Odziedziczone po Stream) |
| FlushAsync(CancellationToken) |
Asynchronicznie zapisuje wszystkie buforowane dane na urządzeniu bazowym. |
| FlushAsync(CancellationToken) |
Asynchronicznie czyści wszystkie bufory dla tego strumienia, powoduje zapisanie wszystkich buforowanych danych na urządzeniu źródłowym i monitorowanie żądań anulowania. (Odziedziczone po Stream) |
| GetHashCode() |
Służy jako domyślna funkcja skrótu. (Odziedziczone po Object) |
| GetLifetimeService() |
Nieaktualne.
Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject) |
| GetType() |
Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object) |
| InitializeLifetimeService() |
Nieaktualne.
Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia. (Odziedziczone po MarshalByRefObject) |
| MemberwiseClone() |
Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object) |
| MemberwiseClone(Boolean) |
Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu. (Odziedziczone po MarshalByRefObject) |
| ObjectInvariant() |
Nieaktualne.
Zapewnia obsługę programu Contract. (Odziedziczone po Stream) |
| Read(Byte[], Int32, Int32) |
Odczytuje dane z tego strumienia i przechowuje je w określonej tablicy. |
| Read(Span<Byte>) |
Po zastąpieniu w klasie pochodnej odczytuje sekwencję bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream) |
| ReadAsync(Byte[], Int32, Int32) |
Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream) |
| ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Odczytuje dane asynchronicznie z tego strumienia i zapisuje je w określonej tablicy. |
| ReadAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia, rozwija pozycję w strumieniu według liczby odczytanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream) |
| ReadAsync(Memory<Byte>, CancellationToken) |
Odczytuje dane asynchronicznie z obiektu NegotiateStream i przechowuje je w zakresie pamięci bajtów jako operację asynchroniczną. |
| ReadAsync(Memory<Byte>, CancellationToken) |
Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia, rozwija pozycję w strumieniu według liczby odczytanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream) |
| ReadAtLeast(Span<Byte>, Int32, Boolean) |
Odczytuje co najmniej minimalną liczbę bajtów z bieżącego strumienia i rozwija pozycję w strumieniu według liczby odczytanych bajtów. (Odziedziczone po Stream) |
| ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken) |
Asynchronicznie odczytuje co najmniej minimalną liczbę bajtów z bieżącego strumienia, zwiększa pozycję w strumieniu według liczby odczytanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream) |
| ReadByte() |
Odczytuje bajt ze strumienia i przesuwa pozycję w strumieniu o jeden bajt lub zwraca wartość -1, jeśli na końcu strumienia. (Odziedziczone po Stream) |
| ReadExactly(Byte[], Int32, Int32) |
Odczytuje |
| ReadExactly(Span<Byte>) |
Odczytuje bajty z bieżącego strumienia i przesuwa pozycję w strumieniu do |
| ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronicznie odczytuje |
| ReadExactlyAsync(Memory<Byte>, CancellationToken) |
Asynchronicznie odczytuje bajty z bieżącego strumienia, przesuwa pozycję w strumieniu do |
| Seek(Int64, SeekOrigin) |
Zgłasza element NotSupportedException. |
| SetLength(Int64) |
Ustawia długość bazowego strumienia. |
| ToString() |
Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object) |
| Write(Byte[], Int32, Int32) |
Zapisz określoną liczbę Bytes do bazowego strumienia przy użyciu określonego buforu i przesunięcia. |
| Write(ReadOnlySpan<Byte>) |
Po zastąpieniu w klasie pochodnej zapisuje sekwencję bajtów do bieżącego strumienia i przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów. (Odziedziczone po Stream) |
| WriteAsync(Byte[], Int32, Int32) |
Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia i przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów. (Odziedziczone po Stream) |
| WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Zapisuj asynchronicznie określoną liczbę Bytes do bazowego strumienia. |
| WriteAsync(Byte[], Int32, Int32, CancellationToken) |
Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia, przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream) |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Zapisuj asynchronicznie określoną liczbę Bytes do bazowego strumienia. |
| WriteAsync(ReadOnlyMemory<Byte>, CancellationToken) |
Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia, przechodzi bieżącą pozycję w tym strumieniu przez liczbę zapisanych bajtów i monitoruje żądania anulowania. (Odziedziczone po Stream) |
| WriteByte(Byte) |
Zapisuje bajt do bieżącej pozycji w strumieniu i przesuwa pozycję w strumieniu o jeden bajt. (Odziedziczone po Stream) |
Metody rozszerzania
| ConfigureAwait(IAsyncDisposable, Boolean) |
Konfiguruje sposób oczekiwania na zadania zwracane z jednorazowego użytku asynchronicznego. |