NegotiateStream Sınıf

Tanım

Ad Alanı:

System.Net.Security

Bütünleştirilmiş Kod:

System.Net.Security.dll

Kaynak:

NegotiateStream.cs

İstemci-sunucu iletişiminde istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için Anlaşma güvenlik protokollerini kullanan bir akış sağlar.

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

Object

MarshalByRefObject

Stream

AuthenticatedStream

NegotiateStream

Örnekler

Aşağıdaki örnekte, NegotiateStreamkullanan bir istemci-sunucu bağlantısının istemci tarafı gösterilmektedir. İstemci kimlik doğrulaması yapar ve sunucuya zaman uyumsuz olarak bir ileti gönderir.

#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ği, istemcinin kimliğini doğrulamak ve istemci tarafından gönderilen iletiyi okumak için NegotiateStream kullanan bir istemci-sunucu bağlantısının sunucu tarafını gösterir.

#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

kimlik doğrulaması için NegotiateStream sınıfını kullanın ve istemci ile sunucu arasında iletilen bilgilerin güvenliğini sağlamaya yardımcı olun. NegotiateStreamkullanarak aşağıdakileri yapabilirsiniz.

• İstemcinin kimlik bilgilerini Kimliğe Bürünme veya Temsilci Seçme için sunucuya gönderin.

• Sunucu kimlik doğrulaması iste.

• Verileri iletmeden önce şifreleyin ve/veya imzalayın.

Kimlik doğrulaması, bilgileri iletmeden önce gerçekleştirilmelidir. İstemciler, kimlik doğrulaması tamamlanana kadar engelleyen zaman uyumlu AuthenticateAsClient yöntemlerini veya kimlik doğrulamasının tamamlanmasını beklerken engellemeyen zaman uyumsuz BeginAuthenticateAsClient yöntemlerini kullanarak kimlik doğrulaması ister. Sunucular zaman uyumlu AuthenticateAsServer veya zaman uyumsuz BeginAuthenticateAsServer yöntemlerini kullanarak kimlik doğrulaması ister. İstemcinin ve isteğe bağlı olarak sunucunun kimliği, Anlaşma güvenlik protokolü kullanılarak doğrulanır. Hem istemci hem de sunucu destekliyorsa, kimlik doğrulaması için Kerberos protokolü kullanılır; aksi takdirde NTLM kullanılır. NegotiateStream sınıfı, Güvenlik Desteği Sağlayıcısı Arabirimi'ni (SSPI) kullanarak kimlik doğrulamasını gerçekleştirir.

Kimlik doğrulaması başarılı olduğunda, NegotiateStream tarafından iletim sırasında verilerinizin güvenliğini sağlamaya yardımcı olmak için hangi güvenlik hizmetlerinin kullanılacağını belirlemek için IsEncrypted ve IsSigned özelliklerini denetlemeniz gerekir. Karşılıklı kimlik doğrulamasının gerçekleşip gerçekleşmediğini belirlemek için IsMutuallyAuthenticated özelliğini denetleyin. RemoteIdentity özelliğini kullanarak uzak istemci veya sunucu hakkında bilgi alabilirsiniz.

Kimlik doğrulaması başarısız olursa bir AuthenticationException veya InvalidCredentialExceptionalırsınız. Bu durumda, kimlik doğrulamasını farklı bir kimlik bilgileriyle yeniden deneyebilirsiniz.

Zaman uyumlu Write veya zaman uyumsuz BeginWrite ya da WriteAsync yöntemlerini kullanarak veri gönderirsiniz. Zaman uyumlu Read veya zaman uyumsuz ReadAsync ya da BeginRead yöntemlerini kullanarak veri alırsınız. Şifreleme veya imzalama gibi güvenlik hizmetleri etkinse, bunlar NegotiateStreamtarafından verilerinize otomatik olarak uygulanır.

NegotiateStream, NegotiateStreamoluştururken sağladığınız bir akışı kullanarak veri aktarır. Bu temel akışı sağladığınızda, NegotiateStream kapatıldığında temel alınan akışın da kapatılıp kapatılmayacağını belirtme seçeneğiniz vardır.

Oluşturucular

NegotiateStream(Stream)	Belirtilen Streamkullanarak NegotiateStream sınıfının yeni bir örneğini başlatır.
NegotiateStream(Stream, Boolean)	Belirtilen Stream ve akış kapatma davranışını kullanarak NegotiateStream sınıfının yeni bir örneğini başlatır.

Özellikler

CanRead	Temel alınan akışın okunabilir olup olmadığını gösteren bir Boolean değeri alır.
CanSeek	Temel alınan akışın aranabilir olup olmadığını gösteren bir Boolean değeri alır.
CanTimeout	Temel alınan akışın zaman aşımlarını destekleyip desteklemediğini gösteren bir Boolean değeri alır.
CanWrite	Temel alınan akışın yazılabilir olup olmadığını gösteren bir Boolean değeri alır.
ImpersonationLevel	Sunucunun istemcinin kimlik bilgilerini nasıl kullanabileceğini gösteren bir değer alır.
InnerStream	Bu AuthenticatedStream tarafından veri göndermek ve almak için kullanılan akışı alır. (Devralındığı yer: AuthenticatedStream)
IsAuthenticated	Kimlik doğrulamasının başarılı olup olmadığını gösteren bir Boolean değeri alır.
IsEncrypted	Bu NegotiateStream veri şifreleme kullanıp kullanmadığını gösteren bir Boolean değeri alır.
IsMutuallyAuthenticated	Hem sunucunun hem de istemcinin kimliğinin doğrulanıp doğrulanmamış olduğunu gösteren bir Boolean değeri alır.
IsServer	Bu NegotiateStream tarafından kullanılan bağlantının yerel tarafının sunucu olarak kimlik doğrulaması yapılıp yapılmadığını gösteren bir Boolean değeri alır.
IsSigned	Bu akış kullanılarak gönderilen verilerin imzalanıp imzalanmadığını gösteren bir Boolean değeri alır.
LeaveInnerStreamOpen	Bu AuthenticatedStream tarafından veri göndermek ve almak için kullanılan akışın açık bırakılıp bırakılmadığını alır. (Devralındığı yer: AuthenticatedStream)
Length	Temel alınan akışın uzunluğunu alır.
Position	Temel alınan akıştaki geçerli konumu alır veya ayarlar.
ReadTimeout	Okuma işleminin veri bekleme süresini alır veya ayarlar.
RemoteIdentity	Bu kimliği doğrulanmış akışı paylaşan uzak tarafın kimliği hakkında bilgi alır.
WriteTimeout	Yazma işleminin veri bekleme süresini alır veya ayarlar.

Yöntemler

AuthenticateAsClient()	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından çağrılır.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi, belirtilen istemci kimlik bilgilerini ve kanal bağlamasını kullanır.
AuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini, kimlik doğrulama seçeneklerini ve kanal bağlamasını kullanır.
AuthenticateAsClient(NetworkCredential, String)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini kullanır.
AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.
AuthenticateAsClientAsync()	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi, belirtilen istemci kimlik bilgilerini ve kanal bağlamasını kullanır.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini, kimlik doğrulama seçeneklerini ve kanal bağlamasını kullanır.
AuthenticateAsClientAsync(NetworkCredential, String)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini kullanır.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemciler tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.
AuthenticateAsServer()	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından çağrılır.
AuthenticateAsServer(ExtendedProtectionPolicy)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır.
AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi belirtilen sunucu kimlik bilgilerini, kimlik doğrulama seçeneklerini ve genişletilmiş koruma ilkesini kullanır.
AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.
AuthenticateAsServerAsync()	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi belirtilen sunucu kimlik bilgilerini, kimlik doğrulama seçeneklerini ve genişletilmiş koruma ilkesini kullanır.
AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)	İstemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için sunucular tarafından zaman uyumsuz bir işlem olarak istemci-sunucu bağlantısında çağrılır. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır.
BeginAuthenticateAsClient(AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler tarafından çağrılır. Bu yöntem engellemez.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kanal bağlamasını kullanır. Bu yöntem engellemez.
BeginAuthenticateAsClient(NetworkCredential, ChannelBinding, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini, kimlik doğrulama seçeneklerini ve kanal bağlamasını kullanır. Bu yöntem engellemez.
BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini kullanır. Bu yöntem engellemez.
BeginAuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için istemciler tarafından çağrılır. Kimlik doğrulama işlemi belirtilen kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır. Bu yöntem engellemez.
BeginAuthenticateAsServer(AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır. Bu yöntem engellemez.
BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır. Bu yöntem engellemez.
BeginAuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi belirtilen sunucu kimlik bilgilerini, kimlik doğrulama seçeneklerini ve genişletilmiş koruma ilkesini kullanır. Bu yöntem engellemez.
BeginAuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel, AsyncCallback, Object)	İstemci-sunucu bağlantısında istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için zaman uyumsuz bir işlem başlatmak için sunucular tarafından çağrılır. Kimlik doğrulama işlemi, belirtilen sunucu kimlik bilgilerini ve kimlik doğrulama seçeneklerini kullanır. Bu yöntem engellemez.
BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)	Akıştaki verileri okuyan ve belirtilen dizide depolayan zaman uyumsuz bir okuma işlemi başlatır.
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)	Belirtilen arabellekten akışa Byteyazan zaman uyumsuz bir yazma işlemi başlatır.
Close()	Geçerli akışı kapatır ve geçerli akışla ilişkili tüm kaynakları (yuvalar ve dosya tanıtıcıları gibi) serbest bırakır. Bu yöntemi çağırmak yerine akışın düzgün şekilde atıldığından emin olun. (Devralındığı yer: Stream)
CopyTo(Stream)	Geçerli akıştan baytları okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyTo(Stream, Int32)	Geçerli akıştan baytları okur ve belirtilen arabellek boyutunu kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, CancellationToken)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen iptal belirtecini kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, Int32)	Geçerli akıştan gelen baytları zaman uyumsuz olarak okur ve belirtilen arabellek boyutunu kullanarak başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (Devralındığı yer: Stream)
CopyToAsync(Stream, Int32, CancellationToken)	Belirtilen arabellek boyutu ve iptal belirtecini kullanarak geçerli akıştan baytları zaman uyumsuz olarak okur ve başka bir akışa yazar. Her iki akış konumu da kopyalanan bayt sayısına göre gelişmiştir. (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 ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
CreateWaitHandle()	Geçersiz. bir WaitHandle nesnesi ayırır. (Devralındığı yer: Stream)
Dispose()	Streamtarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Stream)
Dispose(Boolean)	NegotiateStream tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır.
DisposeAsync()	NegotiateStreamtarafından kullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak serbest bırakır.
EndAuthenticateAsClient(IAsyncResult)	BeginAuthenticateAsClientçağrısıyla başlatılan bekleyen zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır.
EndAuthenticateAsServer(IAsyncResult)	BeginAuthenticateAsServerçağrısıyla başlatılan bekleyen zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır.
EndRead(IAsyncResult)	BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)çağrısıyla başlatılan zaman uyumsuz okuma işlemini sonlandırır.
EndWrite(IAsyncResult)	BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)çağrısıyla başlatılan zaman uyumsuz yazma işlemini sonlandırır.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Flush()	Arabelleğe alınan verilerin temel alınan cihaza yazılması neden olur.
FlushAsync()	Bu akış için tüm arabellekleri zaman uyumsuz olarak temizler ve arabelleğe alınan verilerin temel alınan cihaza yazılmasına neden olur. (Devralındığı yer: Stream)
FlushAsync(CancellationToken)	Arabelleğe alınan tüm verileri zaman uyumsuz olarak temel alınan cihaza yazar.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
ObjectInvariant()	Geçersiz. Contractiçin destek sağlar. (Devralındığı yer: Stream)
Read(Byte[], Int32, Int32)	Bu akıştaki verileri okur ve belirtilen dizide depolar.
Read(Span<Byte>)	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli akıştan bir bayt dizisi okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32)	Geçerli akıştan zaman uyumsuz olarak bir bayt dizisi okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)	Bu akıştaki verileri zaman uyumsuz olarak okur ve belirtilen dizide depolar.
ReadAsync(Memory<Byte>, CancellationToken)	verileri NegotiateStream zaman uyumsuz olarak okur ve zaman uyumsuz bir işlem olarak bayt bellek aralığında depolar.
ReadAtLeast(Span<Byte>, Int32, Boolean)	Geçerli akıştan en az bayt sayısını okur ve okunan bayt sayısına göre akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadAtLeastAsync(Memory<Byte>, Int32, Boolean, CancellationToken)	Geçerli akıştan en az en az sayıda bayt zaman uyumsuz olarak okur, okunan bayt sayısına göre akıştaki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
ReadByte()	Akıştan bir bayt okur ve akışın içindeki konumu bir bayt ilerletir veya akışın sonundaysa -1 döndürür. (Devralındığı yer: Stream)
ReadExactly(Byte[], Int32, Int32)	Geçerli akıştan count bayt sayısını okur ve akış içindeki konumu ilerletir. (Devralındığı yer: Stream)
ReadExactly(Span<Byte>)	Geçerli akıştan baytları okur ve buffer doldurulana kadar akıştaki konumu ilerletir. (Devralındığı yer: Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Geçerli akıştan count bayt sayısını zaman uyumsuz olarak okur, akış içindeki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
ReadExactlyAsync(Memory<Byte>, CancellationToken)	Geçerli akıştaki baytları zaman uyumsuz olarak okur, buffer doldurulana kadar akıştaki konumu ilerletir ve iptal isteklerini izler. (Devralındığı yer: Stream)
Seek(Int64, SeekOrigin)	NotSupportedExceptionatar.
SetLength(Int64)	Temel alınan akışın uzunluğunu ayarlar.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
Write(Byte[], Int32, Int32)	Belirtilen arabellek ve uzaklığı kullanarak temel alınan akışa belirtilen sayıda Byteyazın.
Write(ReadOnlySpan<Byte>)	Türetilmiş bir sınıfta geçersiz kılındığında, geçerli akışa bir bayt dizisi yazar ve yazılan bayt sayısıyla bu akıştaki geçerli konumu ilerletir. (Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32)	Zaman uyumsuz olarak geçerli akışa bir bayt dizisi yazar ve bu akıştaki geçerli konumu yazılan bayt sayısına göre ilerletir. (Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Temel alınan akışa belirtilen sayıda Bytezaman uyumsuz olarak yazın.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Temel alınan akışa belirtilen sayıda Bytezaman uyumsuz olarak yazın.
WriteByte(Byte)	Akıştaki geçerli konuma bir bayt yazar ve akış içindeki konumu bir bayt ilerletir. (Devralındığı yer: Stream)

Uzantı Metotları

CopyToAsync(Stream, PipeWriter, CancellationToken)	Stream baytları zaman uyumsuz olarak okur ve bir iptal belirteci kullanarak belirtilen PipeWriteryazar.
ConfigureAwait(IAsyncDisposable, Boolean)	Zaman uyumsuz bir atılabilir öğeden döndürülen görevlerde awaits işleminin nasıl gerçekleştirileceğini yapılandırılır.

Ayrıca bkz.

• Sürüm 3.5 SP1'de HTTPWebRequest için NTLM kimlik doğrulaması değişiklikleri