NegotiateStream Sınıf

Tanım

İstemcinin kimliğini doğrulamak için Negotiate güvenlik protokolünü ve isteğe bağlı olarak sunucu istemci-sunucu iletişimini kullanarak bir akış sağlar.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
Devralma
Devralma

Örnekler

Aşağıdaki örnekte, kullanan bir istemci-sunucu bağlantısının istemci tarafı gösterilmektedir NegotiateStream .The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. İstemci kimlik doğrulaması yapar ve sunucuya zaman uyumsuz olarak bir ileti gönderir.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.
            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

Aşağıdaki kod örneğinde, istemci NegotiateStream kimliğini doğrulamak ve istemci tarafından gönderilen bir iletiyi okumak için kullanan bir istemci-sunucu bağlantısının sunucu tarafı gösterilmektedir.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;
                // 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(); }
        }
    }
}

Açıklamalar

NegotiateStreamKimlik doğrulaması için sınıfını ve bir istemci ile sunucu arasında iletilen bilgilerin güvenliğini sağlamaya yardımcı olmak için kullanın.Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. Kullanarak NegotiateStream aşağıdakileri yapabilirsiniz.Using NegotiateStream, you can do the following.

  • Kimliğe bürünme veya temsil için istemcinin kimlik bilgilerini sunucuya gönderin.Send the client's credentials to the server for Impersonation or Delegation.

  • Sunucu kimlik doğrulaması iste.Request server authentication.

  • Verileri iletmeden önce şifreleyin ve/veya imzalayın.Encrypt and/or sign data before transmitting it.

Bilgi gönderilmeden önce kimlik doğrulaması yapılmalıdır.Authentication must be performed before transmitting information. İstemciler, kimlik doğrulaması AuthenticateAsClient tamamlanana kadar engelleyen zaman uyumlu yöntemler veya BeginAuthenticateAsClient kimlik doğrulamanın tamamlanmasını beklerken engellenmeden zaman uyumsuz yöntemler kullanarak kimlik doğrulaması ister.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. Sunucular, zaman uyumlu AuthenticateAsServer veya zaman uyumsuz yöntemler kullanarak kimlik doğrulaması ister BeginAuthenticateAsServer .Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. İstemci ve isteğe bağlı olarak sunucu, Negotiate güvenlik protokolü kullanılarak doğrulanır.The client, and optionally the server, is authenticated using the Negotiate security protocol. Windows 95/98 sistemlerinde, Windows NT LAN Manager (NTLM), kimlik doğrulaması için kullanılan protokoldür.On Windows 95/98 systems, Windows NT LAN Manager (NTLM) is the protocol used for authentication. Diğer platformlarda, hem istemci hem de sunucu destekliyorsa, Kerberos protokolü kimlik doğrulaması için kullanılır; Aksi takdirde NTLM kullanılır.On other platforms the Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. Bu protokollerin ayrıntılı açıklamaları için, msdn.microsoft.com/library/adresindeki Platform SDK belgelerine bakın.For detailed descriptions of these protocols, see the Platform SDK documentation on MSDN, at msdn.microsoft.com/library/. NegotiateStreamSınıfı, güvenlik desteği sağlayıcısı arabirimi (SSPI) kullanarak kimlik doğrulamasını gerçekleştirir.The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

Kimlik doğrulaması başarılı olduğunda, IsEncrypted IsSigned NegotiateStream iletim sırasında verilerinizin güvenliğinin sağlanmasına yardımcı olmak için hangi güvenlik hizmetlerinin kullanılacağını belirlemek için ve özelliklerini denetlemeniz gerekir.When 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. IsMutuallyAuthenticatedKarşılıklı kimlik doğrulamanın yapılıp yapılmayacağını öğrenmek için özelliği denetleyin.Check the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. Özelliğini kullanarak uzak istemci veya sunucu hakkında bilgi edinebilirsiniz RemoteIdentity .You can get information about the remote client or server using the RemoteIdentity property.

Kimlik doğrulaması başarısız olursa, bir veya olarak alırsınız AuthenticationException InvalidCredentialException .If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. Bu durumda, farklı bir kimlik bilgisiyle kimlik doğrulamasını yeniden deneyebilirsiniz.In this case, you can retry the authentication with a different credential.

Zaman uyumlu Write veya zaman uyumsuz BeginWrite veya yöntemleri kullanarak veri gönderirsiniz WriteAsync .You send data using the synchronous Write or asynchronous BeginWrite or WriteAsync methods. Zaman uyumlu Read veya zaman uyumsuz ReadAsync veya yöntemleri kullanarak veri alırsınız BeginRead .You receive data using the synchronous Read or asynchronous ReadAsync or BeginRead methods. Şifreleme veya imzalama gibi güvenlik hizmetleri etkinleştirilmişse, bunlar tarafından verilerinize otomatik olarak uygulanır NegotiateStream .If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

, NegotiateStream Verileri oluştururken sağladığınız bir akışı kullanarak iletir NegotiateStream .The NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. Bu temel alınan akışı belirttiğinizde, kapanın, NegotiateStream temel alınan akışı da kapatmayacağını belirtme seçeneğiniz vardır.When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

Oluşturucular

NegotiateStream(Stream)

Belirtilen ' i kullanarak sınıfının yeni bir örneğini başlatır NegotiateStream Stream .Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean)

NegotiateStreamBelirtilen Stream ve akış kapatma davranışını kullanarak sınıfının yeni bir örneğini başlatır.Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

Özellikler

CanRead

BooleanTemel alınan akışın okunabilir olup olmadığını gösteren bir değer alır.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

BooleanTemel alınan akışın aranabilir olup olmadığını gösteren bir değer alır.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

BooleanTemel alınan akışın zaman aşımlarını destekleyip desteklemediğini gösteren bir değer alır.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

BooleanTemel alınan akışın yazılabilir olup olmadığını gösteren bir değer alır.Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel

Sunucunun istemcinin kimlik bilgilerini nasıl kullanacağını gösteren bir değer alır.Gets a value that indicates how the server can use the client's credentials.

InnerStream

Bu tarafından AuthenticatedStream veri göndermek ve almak için kullanılan akışı alır.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Devralındığı yer: AuthenticatedStream)
IsAuthenticated

BooleanKimlik doğrulamanın başarılı olup olmadığını gösteren bir değer alır.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

BooleanBunun veri şifrelemesini kullanıp kullanmadığını gösteren bir değer alır NegotiateStream .Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated

BooleanHem sunucu hem de istemcinin kimliğinin oluşturulup doğrulanmadığını gösteren bir değer alır.Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer

BooleanTarafından kullanılan bağlantının yerel tarafında NegotiateStream sunucu olarak kimlik doğrulaması yapılıp yapılmayacağını gösteren bir değer alır.Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned

BooleanBu akışı kullanarak gönderilen verilerin imzalanıp imzalanmadığını gösteren bir değer alır.Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen

Bu, AuthenticatedStream veri göndermek ve almak için kullanılan akışın açık bırakılmış olup olmadığını alır.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Devralındığı yer: AuthenticatedStream)
Length

Temel alınan akışın uzunluğunu alır.Gets the length of the underlying stream.

Position

Temel alınan akıştaki geçerli konumu alır veya ayarlar.Gets or sets the current position in the underlying stream.

ReadTimeout

Okuma işlemi bloklarının veri beklediği süre miktarını alır veya ayarlar.Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity

Bu kimliği doğrulanmış akışın paylaştığı uzak tarafın kimliği hakkında bilgi alır.Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout

Veri için bekleyen yazma işlemi bloklarının süresini alır veya ayarlar.Gets or sets the amount of time a write operation blocks waiting for data.

Yöntemler

AuthenticateAsClient()

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini ve kanal bağlamayı kullanır.The authentication process uses the specified client credential and the channel binding.

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

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen kimlik bilgisini, kimlik doğrulama seçeneklerini ve kanal bağlamayı kullanır.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String)

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini kullanır.The authentication process uses the specified client credential.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.The authentication process uses the specified credentials and authentication options.

AuthenticateAsClientAsync()

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini ve kanal bağlamayı kullanır.The authentication process uses the specified client credential and the channel binding.

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

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi belirtilen kimlik bilgisini, kimlik doğrulama seçeneklerini ve kanal bağlamayı kullanır.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClientAsync(NetworkCredential, String)

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini kullanır.The authentication process uses the specified client credential.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

İstemcinin kimliğini doğrulamak için istemciler tarafından ve isteğe bağlı olarak sunucu, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer()

İstemcinin kimliğini doğrulamak ve isteğe bağlı olarak sunucusunu istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy)

İstemcinin kimliğini doğrulamak ve isteğe bağlı olarak sunucusunu istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır.The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

İstemcinin kimliğini doğrulamak ve isteğe bağlı olarak sunucusunu istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini, kimlik doğrulama seçeneklerini ve genişletilmiş koruma ilkesini kullanır.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

İstemcinin kimliğini doğrulamak ve isteğe bağlı olarak sunucusunu istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.The authentication process uses the specified server credentials and authentication options.

AuthenticateAsServerAsync()

İstemcinin kimliğini doğrulamak için sunucular tarafından ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsServerAsync(ExtendedProtectionPolicy)

İstemcinin kimliğini doğrulamak için sunucular tarafından ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır.The authentication process uses the specified extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

İstemcinin kimliğini doğrulamak için sunucular tarafından ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini, kimlik doğrulama seçeneklerini ve genişletilmiş koruma ilkesini kullanır.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

İstemcinin kimliğini doğrulamak için sunucular tarafından ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağırılır.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.The authentication process uses the specified server credentials and authentication options.

BeginAuthenticateAsClient(AsyncCallback, Object)

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Bu yöntem engellenmiyor.This method does not block.

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

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kanal bağlamayı kullanır.The authentication process uses the specified credentials and channel binding. Bu yöntem engellenmiyor.This method does not block.

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

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini, kimlik doğrulama seçeneklerini ve kanal bağlamayı kullanır.The authentication process uses the specified credentials, authentication options, and channel binding. Bu yöntem engellenmiyor.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini kullanır.The authentication process uses the specified credentials. Bu yöntem engellenmiyor.This method does not block.

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

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.The authentication process uses the specified credentials and authentication options. Bu yöntem engellenmiyor.This method does not block.

BeginAuthenticateAsServer(AsyncCallback, Object)

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Bu yöntem engellenmiyor.This method does not block.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır.The authentication process uses the specified extended protection policy. Bu yöntem engellenmiyor.This method does not block.

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

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini, kimlik doğrulama seçeneklerini ve genişletilmiş koruma ilkesini kullanır.The authentication process uses the specified server credentials, authentication options, and extended protection policy. Bu yöntem engellenmiyor.This method does not block.

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

İstemcinin kimliğini doğrulamak için zaman uyumsuz bir işlemi başlatmak için ve isteğe bağlı olarak, bir istemci-sunucu bağlantısında sunucu tarafından çağırılır.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.The authentication process uses the specified server credentials and authentication options. Bu yöntem engellenmiyor.This method does not block.

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

Akıştan verileri okuyan ve belirtilen dizide depolayan bir zaman uyumsuz okuma işlemi başlatır.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Zaman uyumsuz okuma işlemi başlatır.Begins an asynchronous read operation. ( ReadAsync(Byte[], Int32, Int32) Bunun yerine kullanmayı düşünün.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Devralındığı yer: Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Belirtilen arabellekten akışa akış yapan bir zaman uyumsuz yazma işlemi başlatır Byte .Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

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

Zaman uyumsuz yazma işlemine başlar.Begins an asynchronous write operation. ( WriteAsync(Byte[], Int32, Int32) Bunun yerine kullanmayı düşünün.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Devralındığı yer: Stream)
Close()

Geçerli akışı kapatır ve geçerli akış ile ilişkili tüm kaynakları (yuvalar ve dosya tutamaçları gibi) yayınlar.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Bu yöntemi çağırmak yerine akışın düzgün şekilde atılmış olduğundan emin olun.Instead of calling this method, ensure that the stream is properly disposed.

(Devralındığı yer: Stream)
CopyTo(Stream)

Geçerli akıştan baytları okur ve bunları başka bir akışa yazar.Reads the bytes from the current stream and writes them to another stream.

(Devralındığı yer: Stream)
CopyTo(Stream, Int32)

Geçerli akıştan baytları okur ve belirtilen arabellek boyutunu kullanarak bunları başka bir akışa yazar.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Devralındığı yer: Stream)
CopyToAsync(Stream)

Geçerli akıştan alınan baytları zaman uyumsuz olarak okur ve bunları başka bir akışa yazar.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Devralındığı yer: Stream)
CopyToAsync(Stream, CancellationToken)

Zaman uyumsuz olarak geçerli akıştan bayt okur ve belirtilen bir iptal belirtecini kullanarak bunları başka bir akışa yazar.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Devralındığı yer: Stream)
CopyToAsync(Stream, Int32)

Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen arabellek boyutunu kullanarak bunları başka bir akışa yazar.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Devralındığı yer: Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Zaman uyumsuz olarak geçerli akıştan bayt okur ve belirtilen arabellek boyutunu ve iptal belirtecini kullanarak bunları başka bir akışa yazar.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Devralındığı yer: Stream)
CreateObjRef(Type)

Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm bilgileri içeren bir nesne oluşturur.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Devralındığı yer: MarshalByRefObject)
CreateWaitHandle()
Kullanımdan kalktı.

Bir WaitHandle nesneyi ayırır.Allocates a WaitHandle object.

(Devralındığı yer: Stream)
Dispose()

Stream tarafından kullanılan tüm kaynakları serbest bırakır.Releases all resources used by the Stream.

(Devralındığı yer: Stream)
Dispose(Boolean)

NegotiateStream tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır.Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

Dispose(Boolean)

AuthenticatedStream tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır.Releases the unmanaged resources used by the AuthenticatedStream and optionally releases the managed resources.

(Devralındığı yer: AuthenticatedStream)
DisposeAsync()

Tarafından kullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak bırakır NegotiateStream .Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

DisposeAsync()

Tarafından kullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak bırakır AuthenticatedStream .Asynchronously releases the unmanaged and managed resources used by the AuthenticatedStream.

(Devralındığı yer: AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Çağrısı ile başlatılan bekleyen bir zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır BeginAuthenticateAsClient .Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Çağrısı ile başlatılan bekleyen bir zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır BeginAuthenticateAsServer .Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult)

Çağrısı ile başlatılan zaman uyumsuz bir okuma işlemini sonlandırır BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) .Ends an asynchronous read operation that was started with a call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndRead(IAsyncResult)

Bekleyen zaman uyumsuz okuma işleminin tamamlanmasını bekler.Waits for the pending asynchronous read to complete. ( ReadAsync(Byte[], Int32, Int32) Bunun yerine kullanmayı düşünün.)(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Devralındığı yer: Stream)
EndWrite(IAsyncResult)

Çağrısı ile başlatılan zaman uyumsuz yazma işlemini sonlandırır BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) .Ends an asynchronous write operation that was started with a call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

Zaman uyumsuz yazma işlemini sonlandırır.Ends an asynchronous write operation. ( WriteAsync(Byte[], Int32, Int32) Bunun yerine kullanmayı düşünün.)(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Devralındığı yer: Stream)
Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
Flush()

Arabelleğe alınan verilerin temeldeki cihaza yazılmasına neden olur.Causes any buffered data to be written to the underlying device.

FlushAsync()

Bu akış için tüm arabellekleri zaman uyumsuz olarak temizler ve arabelleğe alınan verilerin temeldeki cihaza yazılmasına neden olur.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Devralındığı yer: Stream)
FlushAsync(CancellationToken)

Arabelleğe alınan verileri, temeldeki cihaza zaman uyumsuz olarak yazar.Asynchronously writes any buffered data to the underlying device.

FlushAsync(CancellationToken)

Bu akış için tüm arabellekleri zaman uyumsuz olarak temizlemez, ara belleğe alınan verilerin temeldeki cihaza yazılmasına neden olur ve iptal isteklerini izler.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

(Devralındığı yer: Stream)
GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetLifetimeService()

Bu örnek için ömür ilkesini denetleyen geçerli ömür hizmeti nesnesini alır.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
InitializeLifetimeService()

Bu örnek için ömür ilkesini denetlemek üzere bir ömür hizmeti nesnesi alır.Obtains a lifetime service object to control the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
MemberwiseClone(Boolean)

Geçerli nesnenin basit bir kopyasını oluşturur MarshalByRefObject .Creates a shallow copy of the current MarshalByRefObject object.

(Devralındığı yer: MarshalByRefObject)
ObjectInvariant()
Kullanımdan kalktı.

İçin destek sağlar Contract .Provides support for a Contract.

(Devralındığı yer: Stream)
Read(Byte[], Int32, Int32)

Bu akıştan verileri okur ve belirtilen dizide depolar.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

Türetilmiş bir sınıfta geçersiz kılınırsa, geçerli akıştan bir bayt dizisini okur ve okunan bayt sayısıyla akış içindeki konumu ilerletir.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.

(Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32)

Zaman uyumsuz olarak geçerli akıştan bir bayt dizisini okur ve okunan bayt sayısıyla akış içindeki konumu ilerletir.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Verileri bu akıştan zaman uyumsuz olarak okur ve belirtilen dizide depolar.Reads data asynchronously from this stream and stores it in the specified array.

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

Geçerli akıştan bir bayt dizisini zaman uyumsuz olarak okur, okunan bayt sayısıyla akış içindeki konumu ilerletir ve iptal isteklerini izler.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.

(Devralındığı yer: Stream)
ReadAsync(Memory<Byte>, CancellationToken)

' Dan zaman uyumsuz olarak verileri okur NegotiateStream ve bir bayt bellek aralığında zaman uyumsuz bir işlem olarak depolar.Reads data asynchronously from the NegotiateStream and stores it in a byte memory range as an asynchronous operation.

ReadAsync(Memory<Byte>, CancellationToken)

Geçerli akıştan bir bayt dizisini zaman uyumsuz olarak okur, okunan bayt sayısıyla akış içindeki konumu ilerletir ve iptal isteklerini izler.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.

(Devralındığı yer: Stream)
ReadByte()

Akıştan bir bayt okur ve akış içindeki konumu bir bayta ilerletir veya akışın sonunda ise-1 döndürür.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.

(Devralındığı yer: Stream)
Seek(Int64, SeekOrigin)

Atar NotSupportedException .Throws NotSupportedException.

SetLength(Int64)

Temel alınan akışın uzunluğunu ayarlar.Sets the length of the underlying stream.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)
Write(Byte[], Int32, Int32)

Belirtilen Byte arabelleği ve sapmayı kullanarak belirtilen sayıda öğeleri temeldeki akışa yazın.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

Türetilmiş bir sınıfta geçersiz kılınırsa, geçerli akışa bir bayt dizisi yazar ve yazılan bayt sayısıyla bu akış içindeki geçerli konumu ilerletir.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.

(Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32)

Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar ve yazılan bayt sayısıyla bu akış içindeki geçerli konumu ilerletir.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Belirtilen sayıdaki Byte öğeleri temeldeki akışa zaman uyumsuz olarak yaz.Write asynchronously the specified number of Bytes to the underlying stream.

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

Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar, bu akış içindeki geçerli konumu yazılan bayt sayısıyla ilerletir ve iptal isteklerini izler.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.

(Devralındığı yer: Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Belirtilen sayıdaki Byte öğeleri temeldeki akışa zaman uyumsuz olarak yaz.Write asynchronously the specified number of Bytes to the underlying stream.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar, bu akış içindeki geçerli konumu yazılan bayt sayısıyla ilerletir ve iptal isteklerini izler.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.

(Devralındığı yer: Stream)
WriteByte(Byte)

Akıştaki geçerli konuma bir bayt yazar ve akış içindeki konumu bir bayta ilerletir.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Devralındığı yer: Stream)

Belirtik Arabirim Kullanımları

IDisposable.Dispose()

Stream tarafından kullanılan tüm kaynakları serbest bırakır.Releases all resources used by the Stream.

(Devralındığı yer: Stream)

Uzantı Metotları

ConfigureAwait(IAsyncDisposable, Boolean)

Zaman uyumsuz bir atılabilir döndürülen görevlerin ne kadar beklediğini yapılandırır.Configures how awaits on the tasks returned from an async disposable are performed.

Şunlara uygulanır

Ayrıca bkz.