NegotiateStream Klasa

Definicja

Zapewnia strumień, który używa protokołu zabezpieczeń Negocjuj do uwierzytelniania klienta i opcjonalnie serwera w komunikacji klient-serwer.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
Dziedziczenie
Dziedziczenie

Przykłady

Poniższy przykład demonstruje po stronie klienta połączenia klient-serwer, które używa programu NegotiateStream .The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. Klient uwierzytelnia i wysyła komunikat do serwera asynchronicznie.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

Poniższy przykład kodu demonstruje po stronie serwera połączenia klient-serwer, które korzysta z programu, NegotiateStream aby uwierzytelnić klienta i odczytać komunikat Wysłany przez klienta.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(); }
        }
    }
}

Uwagi

Użyj NegotiateStream klasy do uwierzytelniania i zabezpieczania informacji przesyłanych między klientem a serwerem.Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. Korzystając z programu NegotiateStream , można wykonać następujące czynności.Using NegotiateStream, you can do the following.

  • Wyślij poświadczenia klienta na serwer pod kątem personifikacji lub delegowania.Send the client's credentials to the server for Impersonation or Delegation.

  • Żądaj uwierzytelniania serwera.Request server authentication.

  • Szyfruj i/lub podpisz dane przed ich przesłaniem.Encrypt and/or sign data before transmitting it.

Przed przesłaniem informacji należy przeprowadzić uwierzytelnianie.Authentication must be performed before transmitting information. Klienci żądają uwierzytelniania przy użyciu AuthenticateAsClient metod synchronicznych, które blokują do momentu zakończenia uwierzytelniania lub metod asynchronicznych BeginAuthenticateAsClient , które nie są blokowane podczas oczekiwania na ukończenie uwierzytelniania.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. Serwery żądają uwierzytelniania przy użyciu AuthenticateAsServer metod synchronicznych lub asynchronicznych BeginAuthenticateAsServer .Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. Klient i opcjonalnie serwer programu są uwierzytelniani przy użyciu protokołu zabezpieczeń Negocjuj.The client, and optionally the server, is authenticated using the Negotiate security protocol. Protokół Kerberos jest używany do uwierzytelniania, jeśli obsługuje go zarówno klient, jak i serwer; w przeciwnym razie jest używany protokół NTLM.The Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. NegotiateStreamKlasa wykonuje uwierzytelnianie przy użyciu interfejsu dostawcy obsługi zabezpieczeń (SSPI).The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

Po pomyślnym uwierzytelnieniu należy sprawdzić IsEncrypted właściwości i, IsSigned Aby określić, które usługi zabezpieczeń będą używane przez program, NegotiateStream Aby pomóc w zabezpieczeniu danych podczas przesyłania.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. Sprawdź IsMutuallyAuthenticated Właściwość, aby określić, czy nastąpiło wzajemne uwierzytelnianie.Check the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. Możesz uzyskać informacje o kliencie zdalnym lub serwerze przy użyciu RemoteIdentity właściwości.You can get information about the remote client or server using the RemoteIdentity property.

Jeśli uwierzytelnianie nie powiedzie się, zostanie wyświetlony komunikat AuthenticationException lub InvalidCredentialException .If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. W takim przypadku można ponowić próbę uwierzytelnienia przy użyciu innego poświadczenia.In this case, you can retry the authentication with a different credential.

Dane są wysyłane przy użyciu metod synchronicznych Write lub asynchronicznych BeginWrite WriteAsync .You send data using the synchronous Write or asynchronous BeginWrite or WriteAsync methods. Dane są odbierane przy użyciu synchronicznych Read lub asynchronicznych ReadAsync BeginRead metod.You receive data using the synchronous Read or asynchronous ReadAsync or BeginRead methods. Jeśli są włączone usługi zabezpieczeń, takie jak szyfrowanie lub podpisywanie, są one automatycznie stosowane do danych przez NegotiateStream .If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

NegotiateStreamPrzesyła dane przy użyciu strumienia dostarczanego podczas tworzenia NegotiateStream .The NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. Po dostarczeniu tego strumienia bazowego można określić, czy zamknięcie tego NegotiateStream strumienia spowoduje również zamknięcie źródłowego.When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

Konstruktory

NegotiateStream(Stream)

Inicjuje nowe wystąpienie NegotiateStream klasy przy użyciu określonego elementu Stream .Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean)

Inicjuje nowe wystąpienie NegotiateStream klasy przy użyciu określonego Stream i zamknięcia strumienia.Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

Właściwości

CanRead

Pobiera Boolean wartość wskazującą, czy źródłowy strumień jest możliwy do odczytu.Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

Pobiera Boolean wartość wskazującą, czy źródłowy strumień jest możliwy do przeszukania.Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

Pobiera Boolean wartość wskazującą, czy źródłowy strumień obsługuje limity czasu.Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

Pobiera Boolean wartość wskazującą, czy źródłowy strumień jest zapisywalny.Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel

Pobiera wartość wskazującą, w jaki sposób serwer może używać poświadczeń klienta.Gets a value that indicates how the server can use the client's credentials.

InnerStream

Pobiera strumień używany przez ten program AuthenticatedStream do wysyłania i otrzymywania danych.Gets the stream used by this AuthenticatedStream for sending and receiving data.

(Odziedziczone po AuthenticatedStream)
IsAuthenticated

Pobiera Boolean wartość wskazującą, czy uwierzytelnianie zakończyło się pomyślnie.Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

Pobiera Boolean wartość wskazującą, czy jest NegotiateStream używane szyfrowanie danych.Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated

Pobiera Boolean wartość wskazującą, czy zarówno serwer, jak i klient został uwierzytelniony.Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer

Pobiera Boolean wartość wskazującą, czy lokalna strona połączenia używana przez ten program NegotiateStream została uwierzytelniona jako serwer.Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned

Pobiera Boolean wartość wskazującą, czy dane wysyłane przy użyciu tego strumienia są podpisane.Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen

Pobiera informację o tym, czy strumień używany przez ten program AuthenticatedStream do wysyłania i otrzymywania danych został pozostawiony jako otwarty.Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(Odziedziczone po AuthenticatedStream)
Length

Pobiera długość źródłowego strumienia.Gets the length of the underlying stream.

Position

Pobiera lub ustawia bieżącą pozycję w źródłowym strumieniu.Gets or sets the current position in the underlying stream.

ReadTimeout

Pobiera lub ustawia ilość czasu, przez który bloki operacji odczytu oczekują na dane.Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity

Pobiera informacje o tożsamości strony zdalnej udostępniającej ten uwierzytelniony strumień.Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout

Pobiera lub ustawia ilość czasu, w którym bloki operacji zapisu oczekują na dane.Gets or sets the amount of time a write operation blocks waiting for data.

Metody

AuthenticateAsClient()

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonego poświadczenia klienta i powiązania kanału.The authentication process uses the specified client credential and the channel binding.

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

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanałów.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String)

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonego poświadczenia klienta.The authentication process uses the specified client credential.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania.The authentication process uses the specified credentials and authentication options.

AuthenticateAsClientAsync()

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w ramach połączenia klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w ramach połączenia klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonego poświadczenia klienta i powiązania kanału.The authentication process uses the specified client credential and the channel binding.

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

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w ramach połączenia klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanałów.The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClientAsync(NetworkCredential, String)

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w ramach połączenia klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonego poświadczenia klienta.The authentication process uses the specified client credential.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

Wywoływane przez klientów w celu uwierzytelnienia klienta i opcjonalnie serwera w ramach połączenia klienta z serwerem jako operacji asynchronicznej.Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania.The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer()

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy)

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej.The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń serwera, opcji uwierzytelniania i zasad ochrony rozszerzonej.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania.The authentication process uses the specified server credentials and authentication options.

AuthenticateAsServerAsync()

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera, w połączeniu klienta z serwerem jako operacji asynchronicznej.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsServerAsync(ExtendedProtectionPolicy)

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera, w połączeniu klienta z serwerem jako operacji asynchronicznej.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej.The authentication process uses the specified extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera, w połączeniu klienta z serwerem jako operacji asynchronicznej.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonych poświadczeń serwera, opcji uwierzytelniania i zasad ochrony rozszerzonej.The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

Wywoływane przez serwery w celu uwierzytelnienia klienta i opcjonalnie serwera, w połączeniu klienta z serwerem jako operacji asynchronicznej.Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania.The authentication process uses the specified server credentials and authentication options.

BeginAuthenticateAsClient(AsyncCallback, Object)

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Ta metoda nie jest blokowana.This method does not block.

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

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń i powiązania kanałów.The authentication process uses the specified credentials and channel binding. Ta metoda nie jest blokowana.This method does not block.

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

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń, opcji uwierzytelniania i powiązania kanałów.The authentication process uses the specified credentials, authentication options, and channel binding. Ta metoda nie jest blokowana.This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń.The authentication process uses the specified credentials. Ta metoda nie jest blokowana.This method does not block.

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

Wywoływane przez klientów, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń i opcji uwierzytelniania.The authentication process uses the specified credentials and authentication options. Ta metoda nie jest blokowana.This method does not block.

BeginAuthenticateAsServer(AsyncCallback, Object)

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Ta metoda nie jest blokowana.This method does not block.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych zasad ochrony rozszerzonej.The authentication process uses the specified extended protection policy. Ta metoda nie jest blokowana.This method does not block.

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

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń serwera, opcji uwierzytelniania i zasad ochrony rozszerzonej.The authentication process uses the specified server credentials, authentication options, and extended protection policy. Ta metoda nie jest blokowana.This method does not block.

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

Wywoływane przez serwery, aby rozpocząć operację asynchroniczną w celu uwierzytelnienia klienta i opcjonalnie serwera w połączeniu klienta z serwerem.Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. Proces uwierzytelniania używa określonych poświadczeń serwera i opcji uwierzytelniania.The authentication process uses the specified server credentials and authentication options. Ta metoda nie jest blokowana.This method does not block.

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

Rozpoczyna asynchroniczne operacje odczytu, które odczytuje dane ze strumienia i zapisuje je w określonej tablicy.Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

Rozpoczęcie asynchronicznej operacji odczytu.Begins an asynchronous read operation. (Rozważ użycie ReadAsync(Byte[], Int32, Int32) zamiast niego).(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object)

Rozpoczyna asynchroniczne operacje zapisu, które zapisują Byte elementy s z określonego buforu do strumienia.Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

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

Rozpoczyna asynchroniczne operacje zapisu.Begins an asynchronous write operation. (Rozważ użycie WriteAsync(Byte[], Int32, Int32) zamiast niego).(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
Close()

Zamyka bieżący strumień i zwalnia wszystkie zasoby (takie jak gniazda i uchwyty plików) skojarzone z bieżącym strumieniem.Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. Zamiast wywołania tej metody upewnij się, że strumień jest prawidłowo usunięty.Instead of calling this method, ensure that the stream is properly disposed.

(Odziedziczone po Stream)
CopyTo(Stream)

Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu.Reads the bytes from the current stream and writes them to another stream.

(Odziedziczone po Stream)
CopyTo(Stream, Int32)

Odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu.Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Odziedziczone po Stream)
CopyToAsync(Stream)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu.Asynchronously reads the bytes from the current stream and writes them to another stream.

(Odziedziczone po Stream)
CopyToAsync(Stream, CancellationToken)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego tokenu anulowania.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(Odziedziczone po Stream)
CopyToAsync(Stream, Int32)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(Odziedziczone po Stream)
CopyToAsync(Stream, Int32, CancellationToken)

Asynchronicznie odczytuje bajty z bieżącego strumienia i zapisuje je w innym strumieniu przy użyciu określonego rozmiaru buforu i tokenu anulowania.Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(Odziedziczone po Stream)
CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
CreateWaitHandle()
Nieaktualne.

Przydziela WaitHandle obiekt.Allocates a WaitHandle object.

(Odziedziczone po Stream)
Dispose()

Zwalnia wszelkie zasoby używane przez element Stream.Releases all resources used by the Stream.

(Odziedziczone po Stream)
Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element NegotiateStream i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

Dispose(Boolean)

Zwalnia zasoby niezarządzane używane przez element AuthenticatedStream i opcjonalnie zwalnia zasoby zarządzane.Releases the unmanaged resources used by the AuthenticatedStream and optionally releases the managed resources.

(Odziedziczone po AuthenticatedStream)
DisposeAsync()

Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez NegotiateStream .Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

DisposeAsync()

Asynchronicznie zwalnia niezarządzane i zarządzane zasoby używane przez AuthenticatedStream .Asynchronously releases the unmanaged and managed resources used by the AuthenticatedStream.

(Odziedziczone po AuthenticatedStream)
EndAuthenticateAsClient(IAsyncResult)

Zakończenie oczekującej asynchronicznej operacji uwierzytelniania klienta, która została uruchomiona z wywołaniem do BeginAuthenticateAsClient .Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

Zakończenie oczekującej asynchronicznej operacji uwierzytelniania klienta, która została uruchomiona z wywołaniem do BeginAuthenticateAsServer .Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult)

Zamyka asynchroniczną operację odczytu, która została rozpoczęta z wywołaniem do 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)

Czeka na zakończenie oczekujących asynchronicznych operacji odczytu.Waits for the pending asynchronous read to complete. (Rozważ użycie ReadAsync(Byte[], Int32, Int32) zamiast niego).(Consider using ReadAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
EndWrite(IAsyncResult)

Zamyka asynchroniczną operację zapisu, która została uruchomiona z wywołaniem do 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)

Zamyka asynchroniczne operacje zapisu.Ends an asynchronous write operation. (Rozważ użycie WriteAsync(Byte[], Int32, Int32) zamiast niego).(Consider using WriteAsync(Byte[], Int32, Int32) instead.)

(Odziedziczone po Stream)
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
Flush()

Powoduje, że wszystkie buforowane dane są zapisywane na podstawowym urządzeniu.Causes any buffered data to be written to the underlying device.

FlushAsync()

Asynchronicznie czyści wszystkie bufory dla tego strumienia i powoduje, że wszystkie buforowane dane są zapisywane na podstawowym urządzeniu.Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(Odziedziczone po Stream)
FlushAsync(CancellationToken)

Asynchronicznie zapisuje wszystkie dane buforowane na podstawowym urządzeniu.Asynchronously writes any buffered data to the underlying device.

FlushAsync(CancellationToken)

Asynchronicznie czyści wszystkie bufory dla tego strumienia, powoduje, że wszystkie buforowane dane są zapisywane na podstawowym urządzeniu i monitoruje żądania anulowania.Asynchronously clears all buffers for this stream, causes any buffered data to be written to the underlying device, and monitors cancellation requests.

(Odziedziczone po Stream)
GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()
Nieaktualne.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()
Nieaktualne.

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
ObjectInvariant()
Nieaktualne.

Zapewnia pomoc techniczną dla programu Contract .Provides support for a Contract.

(Odziedziczone po Stream)
Read(Byte[], Int32, Int32)

Odczytuje dane z tego strumienia i zapisuje je w określonej tablicy.Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

Gdy jest zastępowany w klasie pochodnej, odczytuje sekwencję bajtów z bieżącego strumienia i przesuwa pozycję w strumieniu o liczbę odczytanych bajtów.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.

(Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32)

Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia i przesuwa pozycję w strumieniu o liczbę odczytanych bajtów.Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(Odziedziczone po Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

Odczytuje dane asynchroniczne z tego strumienia i zapisuje je w określonej tablicy.Reads data asynchronously from this stream and stores it in the specified array.

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

Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia, przesuwa pozycję w strumieniu o liczbę odczytanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
ReadAsync(Memory<Byte>, CancellationToken)

Odczytuje dane asynchroniczne z NegotiateStream i zapisuje je w zakresie pamięci bajtowej jako operacji asynchronicznej.Reads data asynchronously from the NegotiateStream and stores it in a byte memory range as an asynchronous operation.

ReadAsync(Memory<Byte>, CancellationToken)

Asynchronicznie odczytuje sekwencję bajtów z bieżącego strumienia, przesuwa pozycję w strumieniu o liczbę odczytanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
ReadByte()

Odczytuje bajt ze strumienia i przesuwa pozycję w strumieniu o jeden bajt lub zwraca wartość-1, jeśli na końcu strumienia.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.

(Odziedziczone po Stream)
Seek(Int64, SeekOrigin)

Zgłasza NotSupportedException .Throws NotSupportedException.

SetLength(Int64)

Ustawia długość źródłowego strumienia.Sets the length of the underlying stream.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
Write(Byte[], Int32, Int32)

Napisz określoną liczbę Byte s do źródłowego strumienia przy użyciu określonego buforu i przesunięcia.Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

Gdy jest zastępowany w klasie pochodnej, zapisuje sekwencję bajtów do bieżącego strumienia i zwiększa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów.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.

(Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32)

Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia i przesuwa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów.Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(Odziedziczone po Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

Zapisz asynchronicznie określoną liczbę Byte s do źródłowego strumienia.Write asynchronously the specified number of Bytes to the underlying stream.

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

Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia, przesuwa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Zapisz asynchronicznie określoną liczbę Byte s do źródłowego strumienia.Write asynchronously the specified number of Bytes to the underlying stream.

WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

Asynchronicznie zapisuje sekwencję bajtów do bieżącego strumienia, przesuwa bieżącą pozycję w tym strumieniu o liczbę zapisanych bajtów i monitoruje żądania anulowania.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.

(Odziedziczone po Stream)
WriteByte(Byte)

Zapisuje bajty w bieżącym położeniu w strumieniu i przesuwa pozycję w strumieniu o jeden bajt.Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(Odziedziczone po Stream)

Jawne implementacje interfejsu

IDisposable.Dispose()

Zwalnia wszelkie zasoby używane przez element Stream.Releases all resources used by the Stream.

(Odziedziczone po Stream)

Metody rozszerzania

ConfigureAwait(IAsyncDisposable, Boolean)

Określa, jak oczekują oczekiwania na zadania zwracane z asynchronicznej operacji tworzenia.Configures how awaits on the tasks returned from an async disposable are performed.

Dotyczy