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 Negotiate güvenlik protokolunu 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 örnek, kullanan NegotiateStreambir istemci-sunucu bağlantısının istemci tarafını gösterir. İ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 bir iletiyi okumak için kullanan NegotiateStream 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

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

• Kimliğe Bürünme veya Temsilci Seçme için istemcinin kimlik bilgilerini 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öntemleri veya kimlik doğrulamasının tamamlanmasını beklerken engellemeyen zaman uyumsuz BeginAuthenticateAsClient yöntemleri kullanarak kimlik doğrulaması ister. Sunucular zaman uyumlu AuthenticateAsServer veya zaman uyumsuz BeginAuthenticateAsServer yöntemleri 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. Kerberos protokolü, hem istemci hem de sunucu tarafından destekleniyorsa kimlik doğrulaması için kullanılır; aksi takdirde NTLM kullanılır. NegotiateStream sınıfı, Güvenlik Desteği Sağlayıcısı Arabirimini (SSPI) kullanarak kimlik doğrulamasını gerçekleştirir.

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

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

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

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

Oluşturucular

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

Özellikler

CanRead	Temel alınan akışın okunabilir olup olmadığını gösteren bir Boolean değer alır.
CanSeek	Temel alınan akışın aranabilir olup olmadığını gösteren bir Boolean değer alır.
CanTimeout	Temel alınan akışın zaman aşımlarını destekleyip desteklemediğini gösteren bir Boolean değer alır.
CanWrite	Temel alınan akışın yazılabilir olup olmadığını gösteren bir Boolean değer alır.
ImpersonationLevel	Sunucunun istemcinin kimlik bilgilerini nasıl kullanabileceğini gösteren bir değer alır.
InnerStream	Veri göndermek ve almak için bu AuthenticatedStream akış tarafından 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ğer alır.
IsEncrypted	Bunun NegotiateStream veri şifreleme kullanıp kullanmadığını gösteren bir Boolean değer alır.
IsMutuallyAuthenticated	Hem sunucunun hem de istemcinin kimliğinin doğrulanıp doğrulanmamış olduğunu gösteren bir Boolean değer alır.
IsServer	Bunun 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ğer alır.
IsSigned	Bu akış kullanılarak gönderilen verilerin imzalanıp imzalanmadığını belirten bir Boolean değer alır.
LeaveInnerStreamOpen	Bu AuthenticatedStream akış 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()	İstemciler tarafından istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağrılır.
AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)	İstemciler tarafından istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak ç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)	İstemciler tarafından istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak ç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)	İstemciler tarafından istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak çağrılır. Kimlik doğrulama işlemi belirtilen istemci kimlik bilgilerini kullanır.
AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)	İstemciler tarafından istemcinin ve isteğe bağlı olarak sunucunun kimliğini doğrulamak için istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak ç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 kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak sunucu, istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak kullanılır.
AuthenticateAsServerAsync(ExtendedProtectionPolicy)	İstemcinin kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak sunucu, istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak kullanılır. Kimlik doğrulama işlemi belirtilen genişletilmiş koruma ilkesini kullanır.
AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)	İstemcinin kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak sunucu, istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak kullanı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 kimliğini doğrulamak için sunucular tarafından çağrılır ve isteğe bağlı olarak sunucu, istemci-sunucu bağlantısında zaman uyumsuz bir işlem olarak kullanı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 s yazan Bytezaman 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 bir ş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 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 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 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()	Stream tarafı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 yönetilen kaynakları isteğe bağlı olarak serbest bırakır.
DisposeAsync()	tarafından NegotiateStreamkullanılan yönetilmeyen ve yönetilen kaynakları zaman uyumsuz olarak serbest bırakır.
EndAuthenticateAsClient(IAsyncResult)	çağrısıyla BeginAuthenticateAsClientbaşlatılan bekleyen zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır.
EndAuthenticateAsServer(IAsyncResult)	çağrısıyla BeginAuthenticateAsServerbaşlatılan bekleyen zaman uyumsuz istemci kimlik doğrulama işlemini sonlandırır.
EndRead(IAsyncResult)	çağrısıyla BeginRead(Byte[], Int32, Int32, AsyncCallback, Object)başlatılan zaman uyumsuz okuma işlemini sonlandırır.
EndWrite(IAsyncResult)	çağrısıyla BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)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ına 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()	Type Geçerli örneğini 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 Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
ObjectInvariant()	Geçersiz. için Contractdestek 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)	Verileri bu akıştan zaman uyumsuz olarak okur ve belirtilen dizide depolar.
ReadAsync(Memory<Byte>, CancellationToken)	verilerinden 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 zaman uyumsuz olarak en az sayıda bayt okur, okunan bayt sayısına göre akış içindeki 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)	count Geçerli akıştan 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 doldurulana kadar buffer akış içindeki konumu ilerler. (Devralındığı yer: Stream)
ReadExactlyAsync(Byte[], Int32, Int32, CancellationToken)	Geçerli akıştaki bayt sayısını zaman uyumsuz olarak okur count , 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, doldurulana kadar buffer akış içindeki konumu ilerler ve iptal isteklerini izler. (Devralındığı yer: Stream)
Seek(Int64, SeekOrigin)	NotSupportedExceptionoluşturur.
SetLength(Int64)	Temel alınan akışın uzunluğunu ayarlar.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)
Write(Byte[], Int32, Int32)	Belirtilen arabellek ve uzaklığı kullanarak temel alınan akışa belirtilen s sayısını 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ına göre 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 yazılan bayt sayısına göre bu akıştaki geçerli konumu ilerletir. (Devralındığı yer: Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)	Temel alınan akışa belirtilen sayıda Bytes değerini zaman uyumsuz olarak yazın.
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)	Temel alınan akışa belirtilen sayıda Bytes değerini zaman uyumsuz olarak yazın.
WriteByte(Byte)	Akıştaki geçerli konuma bir bayt yazar ve akışın içindeki konumu bir bayt ilerletir. (Devralındığı yer: Stream)

Uzantı Metotları

ConfigureAwait(IAsyncDisposable, Boolean)

Zaman uyumsuz bir atılabilir öğeden döndürülen görevlerde awaits işleminin nasıl gerçekleştirildiğini yapılandıran.

Ayrıca bkz.

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