NegotiateStream クラス

定義

クライアント サーバー通信で Negotiate セキュリティ プロトコルを使用してクライアントの認証と (オプションで) サーバーの認証を行うストリームを提供します。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
継承

次の例は、NegotiateStreamを使用するクライアントとサーバー間の接続のクライアント側を示しています。The following example demonstrates the client side of a client-server connection that uses the NegotiateStream. クライアントは認証を行い、メッセージをサーバーに非同期的に送信します。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.
            IAsyncResult ar = authStream.BeginAuthenticateAsClient(
                new AsyncCallback(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.
            byte[] message = Encoding.UTF8.GetBytes("Hello from the client.");
            ar = authStream.BeginWrite(message, 0, message.Length,
                new AsyncCallback(EndWriteCallback),
                authStream);
            ar.AsyncWaitHandle.WaitOne();
            Console.WriteLine("Sent {0} bytes.", message.Length);
            // Close the client connection.
            authStream.Close();
            Console.WriteLine("Client closed.");
        }
        // The following method is called when the authentication completes.
        public static void EndAuthenticateCallback (IAsyncResult ar)
        {
            Console.WriteLine("Client ending authentication...");
            NegotiateStream authStream = (NegotiateStream) ar.AsyncState;
            Console.WriteLine("ImpersonationLevel: {0}", authStream.ImpersonationLevel);

            // End the asynchronous operation.
            authStream.EndAuthenticateAsClient(ar);
        }
        // The following method is called when the write operation completes.
        public static void EndWriteCallback (IAsyncResult ar)
        {
            Console.WriteLine("Client ending write operation...");
            NegotiateStream authStream = (NegotiateStream) ar.AsyncState;

            // End the asynchronous operation.
            authStream.EndWrite(ar);
        }
    }

    // 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

次のコード例は、NegotiateStream を使用してクライアントを認証し、クライアントから送信されたメッセージを読み取るクライアントとサーバー間の接続のサーバー側を示しています。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 = null;
                // 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);
                    continue;
                }

            }
        
        }
        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.
            authStream.BeginAuthenticateAsServer (
                new AsyncCallback(EndAuthenticateCallback),
                cState
                );
            // Wait until the authentication completes.
            cState.Waiter.WaitOne();
            cState.Waiter.Reset();
            authStream.BeginRead(cState.Buffer, 0, cState.Buffer.Length, 
                   new AsyncCallback(EndReadCallback), 
                   cState);
            cState.Waiter.WaitOne();
            // Finished with the current client.
            authStream.Close();
            clientRequest.Close();
        }
        // The following method is invoked by the
        // BeginAuthenticateAsServer callback delegate.

        public static void EndAuthenticateCallback (IAsyncResult ar)
        {
            // Get the saved data.
            ClientState cState = (ClientState) ar.AsyncState;
            TcpClient clientRequest = cState.Client;
            NegotiateStream authStream = (NegotiateStream) cState.AuthenticatedStream;
            Console.WriteLine("Ending authentication.");
            // Any exceptions that occurred during authentication are
            // thrown by the EndAuthenticateAsServer method.
            try 
            {
                // This call blocks until the authentication is complete.
                authStream.EndAuthenticateAsServer(ar);
            }
            catch (AuthenticationException e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Authentication failed - closing connection.");
                cState.Waiter.Set();
                return;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                Console.WriteLine("Closing connection.");
                cState.Waiter.Set();
                return;
            }
            // Display properties of the authenticated client.
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} was authenticated using {1}.", 
                id.Name, 
                id.AuthenticationType
                );
            cState.Waiter.Set();

    }
        public static void EndReadCallback(IAsyncResult ar)
        {
            // Get the saved data.
            ClientState cState = (ClientState) ar.AsyncState;
            TcpClient clientRequest = cState.Client;
            NegotiateStream authStream = (NegotiateStream) cState.AuthenticatedStream; 
            // 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, 
                               new AsyncCallback(EndReadCallback), 
                               cState);
                               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);
                cState.Waiter.Set();
                return;
            }
            IIdentity id = authStream.RemoteIdentity;
            Console.WriteLine("{0} says {1}", id.Name, cState.Message.ToString());
            cState.Waiter.Set();
        }
    }
    // ClientState is the AsyncState object.
    internal class ClientState
    {
        private AuthenticatedStream authStream = null;
        private  TcpClient client = null;
        byte[] buffer = new byte[2048];
        StringBuilder message = null;
        ManualResetEvent waiter = new ManualResetEvent(false);
        internal ClientState(AuthenticatedStream a, TcpClient theClient)
        {
            authStream = a;
            client = theClient;
        }
        internal TcpClient Client
        { 
            get { return client;}
        }
        internal AuthenticatedStream AuthenticatedStream
        {
            get { return authStream;}
        }
        internal byte[] Buffer
        {
              get { return buffer;}
        }
        internal StringBuilder Message
        {
            get 
            { 
                if (message == null)
                    message = new StringBuilder();
                return message;
             }
        }
        internal ManualResetEvent Waiter
        {
            get 
            { 
                return waiter;
             }
        }
    }
}

注釈

認証には NegotiateStream クラスを使用し、クライアントとサーバーの間で送信される情報をセキュリティで保護するために使用します。Use the NegotiateStream class for authentication and to help secure information transmitted between a client and a server. NegotiateStreamを使用すると、次の操作を実行できます。Using NegotiateStream, you can do the following.

  • 偽装または委任のために、クライアントの資格情報をサーバーに送信します。Send the client's credentials to the server for Impersonation or Delegation.

  • サーバー認証を要求します。Request server authentication.

  • 転送前にデータを暗号化または署名します。Encrypt and/or sign data before transmitting it.

情報を送信する前に認証を実行する必要があります。Authentication must be performed before transmitting information. クライアントは、認証が完了するまでブロックする同期 AuthenticateAsClient メソッド、または認証の完了を待機している間にブロックされない非同期の BeginAuthenticateAsClient メソッドを使用して認証を要求します。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. サーバーは、同期 AuthenticateAsServer または非同期の BeginAuthenticateAsServer メソッドを使用して認証を要求します。Servers request authentication using the synchronous AuthenticateAsServer or asynchronous BeginAuthenticateAsServer methods. クライアント (オプションでサーバー) は、Negotiate セキュリティプロトコルを使用して認証されます。The client, and optionally the server, is authenticated using the Negotiate security protocol. Windows 95/98 システムでは、Windows NT LAN Manager (NTLM) は認証に使用されるプロトコルです。On Windows 95/98 systems, Windows NT LAN Manager (NTLM) is the protocol used for authentication. 他のプラットフォームでは、クライアントとサーバーの両方がサポートする場合、Kerberos プロトコルが認証に使用されます。それ以外の場合は NTLM が使用されます。On other platforms the Kerberos protocol is used for authentication if both client and server support it; otherwise NTLM is used. これらのプロトコルの詳細については、MSDN のプラットフォーム SDK ドキュメント (msdn.microsoft.com/library/) を参照してください。For detailed descriptions of these protocols, see the Platform SDK documentation on MSDN, at msdn.microsoft.com/library/. NegotiateStream クラスは、セキュリティサポートプロバイダインターフェイス (SSPI) を使用して認証を実行します。The NegotiateStream class performs the authentication using the Security Support Provider Interface (SSPI).

認証が成功したら、IsEncryptedIsSigned のプロパティを確認して、転送中にデータをセキュリティで保護するために NegotiateStream によって使用されるセキュリティサービスを決定する必要があります。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. IsMutuallyAuthenticated プロパティを調べて、相互認証が行われたかどうかを確認します。Check the IsMutuallyAuthenticated property to determine whether mutual authentication occurred. リモートクライアントまたはサーバーに関する情報は、RemoteIdentity プロパティを使用して取得できます。You can get information about the remote client or server using the RemoteIdentity property.

認証に失敗すると、AuthenticationException または InvalidCredentialExceptionが表示されます。If the authentication fails, you will receive an AuthenticationException or a InvalidCredentialException. この場合は、別の資格情報で認証を再試行できます。In this case, you can retry the authentication with a different credential.

同期 Write または非同期の BeginWrite メソッドを使用してデータを送信します。You send data using the synchronous Write or asynchronous BeginWrite methods. 同期 Read または非同期の BeginRead メソッドを使用してデータを受信します。You receive data using the synchronous Read or asynchronous BeginRead methods. 暗号化や署名などのセキュリティサービスが有効になっている場合は、NegotiateStreamによってデータに自動的に適用されます。If security services such as encryption or signing are enabled, these are automatically applied to your data by the NegotiateStream.

NegotiateStream は、NegotiateStreamの作成時に指定したストリームを使用してデータを転送します。The NegotiateStream transmits data using a stream that you supply when creating the NegotiateStream. この基になるストリームを指定する場合は、NegotiateStream を閉じるか、基になるストリームも閉じるかどうかを指定するオプションがあります。When you supply this underlying stream, you have the option to specify whether closing the NegotiateStream also closes the underlying stream.

コンストラクター

NegotiateStream(Stream)

指定した Stream を使用して NegotiateStream クラスの新しいインスタンスを初期化します。Initializes a new instance of the NegotiateStream class using the specified Stream.

NegotiateStream(Stream, Boolean)

指定した Stream とストリームを閉じる動作を使用して、NegotiateStream クラスの新しいインスタンスを初期化します。Initializes a new instance of the NegotiateStream class using the specified Stream and stream closure behavior.

プロパティ

CanRead

基になるストリームが読み取り可能かどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether the underlying stream is readable.

CanSeek

基になるストリームがシークできるかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether the underlying stream is seekable.

CanTimeout

基になるストリームがタイムアウトをサポートしているかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether the underlying stream supports time-outs.

CanWrite

基になるストリームが書き込み可能かどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether the underlying stream is writable.

ImpersonationLevel

サーバーでクライアントの資格情報を使用する方法を示す値を取得します。Gets a value that indicates how the server can use the client's credentials.

InnerStream

この AuthenticatedStream がデータの送受信に使用するストリームを取得します。Gets the stream used by this AuthenticatedStream for sending and receiving data.

(継承元 AuthenticatedStream)
IsAuthenticated

認証が成功したかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether authentication was successful.

IsEncrypted

この NegotiateStream がデータの暗号化を使用するかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether this NegotiateStream uses data encryption.

IsMutuallyAuthenticated

サーバーとクライアントの両方が認証されているかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether both the server and the client have been authenticated.

IsServer

この NegotiateStream が使用する接続のローカル側がサーバーとして認証されたかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether the local side of the connection used by this NegotiateStream was authenticated as the server.

IsSigned

このストリームを使用して送信されるデータに署名するかどうかを示す Boolean 値を取得します。Gets a Boolean value that indicates whether the data sent using this stream is signed.

LeaveInnerStreamOpen

この AuthenticatedStream がデータの送受信に使用するストリームが、開いたままになっているかどうかを示す値を取得します。Gets whether the stream used by this AuthenticatedStream for sending and receiving data has been left open.

(継承元 AuthenticatedStream)
Length

基になるストリームの長さを取得します。Gets the length of the underlying stream.

Position

基になるストリーム内の現在位置を取得または設定します。Gets or sets the current position in the underlying stream.

ReadTimeout

読み取り操作がブロックしてデータを待機する時間を取得または設定します。Gets or sets the amount of time a read operation blocks waiting for data.

RemoteIdentity

この認証されたストリームを共有するリモート側の ID に関する情報を取得します。Gets information about the identity of the remote party sharing this authenticated stream.

WriteTimeout

書き込み操作がブロックしてデータを待機する時間を取得または設定します。Gets or sets the amount of time a write operation blocks waiting for data.

メソッド

AuthenticateAsClient()

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsClient(NetworkCredential, ChannelBinding, String)

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定したクライアントの資格情報およびチャネル バインディングが使用されます。The authentication process uses the specified client credential and the channel binding.

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

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した資格情報、認証オプション、およびチャネル バインディングが使用されます。The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClient(NetworkCredential, String)

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定したクライアントの資格情報を使用します。The authentication process uses the specified client credential.

AuthenticateAsClient(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した資格情報と認証オプションを使用します。The authentication process uses the specified credentials and authentication options.

AuthenticateAsClientAsync()

クライアントによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsClientAsync(NetworkCredential, ChannelBinding, String)

クライアントによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定したクライアントの資格情報およびチャネル バインディングが使用されます。The authentication process uses the specified client credential and the channel binding.

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

クライアントによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定した資格情報、認証オプション、およびチャネル バインディングが使用されます。The authentication process uses the specified credential, authentication options, and channel binding.

AuthenticateAsClientAsync(NetworkCredential, String)

クライアントによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定したクライアントの資格情報を使用します。The authentication process uses the specified client credential.

AuthenticateAsClientAsync(NetworkCredential, String, ProtectionLevel, TokenImpersonationLevel)

クライアントによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by clients to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定した資格情報と認証オプションを使用します。The authentication process uses the specified credentials and authentication options.

AuthenticateAsServer()

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection.

AuthenticateAsServer(ExtendedProtectionPolicy)

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した拡張保護ポリシーが使用されます。The authentication process uses the specified extended protection policy.

AuthenticateAsServer(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定したサーバーの資格情報、認証オプション、および拡張保護ポリシーが使用されます。The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServer(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定したサーバーの資格情報と認証オプションを使用します。The authentication process uses the specified server credentials and authentication options.

AuthenticateAsServerAsync()

サーバーによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation.

AuthenticateAsServerAsync(ExtendedProtectionPolicy)

サーバーによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定した拡張保護ポリシーが使用されます。The authentication process uses the specified extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ExtendedProtectionPolicy, ProtectionLevel, TokenImpersonationLevel)

サーバーによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定したサーバーの資格情報、認証オプション、および拡張保護ポリシーが使用されます。The authentication process uses the specified server credentials, authentication options, and extended protection policy.

AuthenticateAsServerAsync(NetworkCredential, ProtectionLevel, TokenImpersonationLevel)

サーバーによって呼び出され、クライアントとサーバー間の接続で非同期操作としてクライアントと (オプションで) サーバーを認証します。Called by servers to authenticate the client, and optionally the server, in a client-server connection as an asynchronous operation. 認証プロセスでは、指定したサーバーの資格情報と認証オプションを使用します。The authentication process uses the specified server credentials and authentication options.

BeginAuthenticateAsClient(AsyncCallback, Object)

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. このメソッドはブロックしません。This method does not block.

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

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した資格情報およびチャネル バインディングが使用されます。The authentication process uses the specified credentials and channel binding. このメソッドはブロックしません。This method does not block.

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

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した資格情報、認証オプション、およびチャネル バインディングが使用されます。The authentication process uses the specified credentials, authentication options, and channel binding. このメソッドはブロックしません。This method does not block.

BeginAuthenticateAsClient(NetworkCredential, String, AsyncCallback, Object)

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した資格情報を使用します。The authentication process uses the specified credentials. このメソッドはブロックしません。This method does not block.

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

クライアントによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by clients to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した資格情報と認証オプションを使用します。The authentication process uses the specified credentials and authentication options. このメソッドはブロックしません。This method does not block.

BeginAuthenticateAsServer(AsyncCallback, Object)

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. このメソッドはブロックしません。This method does not block.

BeginAuthenticateAsServer(ExtendedProtectionPolicy, AsyncCallback, Object)

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定した拡張保護ポリシーが使用されます。The authentication process uses the specified extended protection policy. このメソッドはブロックしません。This method does not block.

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

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定したサーバーの資格情報、認証オプション、および拡張保護ポリシーが使用されます。The authentication process uses the specified server credentials, authentication options, and extended protection policy. このメソッドはブロックしません。This method does not block.

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

サーバーによって呼び出され、クライアントとサーバー間の接続でクライアントと (オプションで) サーバーを認証する非同期操作を開始します。Called by servers to begin an asynchronous operation to authenticate the client, and optionally the server, in a client-server connection. 認証プロセスでは、指定したサーバーの資格情報と認証オプションを使用します。The authentication process uses the specified server credentials and authentication options. このメソッドはブロックしません。This method does not block.

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

ストリームからデータを読み取り、指定した配列に格納する非同期読み取り操作を開始します。Begins an asynchronous read operation that reads data from the stream and stores it in the specified array.

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

指定したバッファーからストリームに Byte を書き込む非同期書き込み操作を開始します。Begins an asynchronous write operation that writes Bytes from the specified buffer to the stream.

Close()

現在のストリームを閉じ、現在のストリームに関連付けられているすべてのリソース (ソケット、ファイル ハンドルなど) を解放します。Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream. このメソッドを呼び出す代わりに、ストリームが適切に破棄されていることを確認します。Instead of calling this method, ensure that the stream is properly disposed.

(継承元 Stream)
CopyTo(Stream)

現在のストリームからバイトを読み取り、別のストリームに書き込みます。Reads the bytes from the current stream and writes them to another stream.

(継承元 Stream)
CopyTo(Stream, Int32)

指定されたバッファー サイズを使用して、現在のストリームからバイトを読み取り、別のストリームに書き込みます。Reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(継承元 Stream)
CopyToAsync(Stream)

現在のストリームからすべてのバイトを非同期に読み取り、別のストリームに書き込みます。Asynchronously reads the bytes from the current stream and writes them to another stream.

(継承元 Stream)
CopyToAsync(Stream, CancellationToken)

指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたキャンセル トークンを使用して、別のストリームに書き込みます。Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified cancellation token.

(継承元 Stream)
CopyToAsync(Stream, Int32)

指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、別のストリームに書き込みます。Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size.

(継承元 Stream)
CopyToAsync(Stream, Int32, CancellationToken)

指定されたバッファー サイズを使用して、現在のストリームからバイトを非同期に読み取り、指定されたバッファー サイズとキャンセル トークンを使用して、別のストリームに書き込みます。Asynchronously reads the bytes from the current stream and writes them to another stream, using a specified buffer size and cancellation token.

(継承元 Stream)
CreateObjRef(Type)

リモート オブジェクトとの通信に使用するプロキシの生成に必要な情報をすべて格納しているオブジェクトを作成します。Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(継承元 MarshalByRefObject)
CreateWaitHandle()

WaitHandle オブジェクトを割り当てます。Allocates a WaitHandle object.

(継承元 Stream)
Dispose()

Stream によって使用されているすべてのリソースを解放します。Releases all resources used by the Stream.

(継承元 Stream)
Dispose(Boolean)

NegotiateStream によって使用されているアンマネージド リソースを解放し、オプションでマネージド リソースも解放します。Releases the unmanaged resources used by the NegotiateStream and optionally releases the managed resources.

DisposeAsync()

NegotiateStream によって使用されているアンマネージドまたはマネージド リソースを非同期に解放します。Asynchronously releases the unmanaged and managed resources used by the NegotiateStream.

EndAuthenticateAsClient(IAsyncResult)

BeginAuthenticateAsClient の呼び出しで開始した保留中の非同期のクライアント認証操作を終了します。Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsClient.

EndAuthenticateAsServer(IAsyncResult)

BeginAuthenticateAsServer の呼び出しで開始した保留中の非同期のクライアント認証操作を終了します。Ends a pending asynchronous client authentication operation that was started with a call to BeginAuthenticateAsServer.

EndRead(IAsyncResult)

BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) の呼び出しで開始された、非同期の読み取り操作を終了します。Ends an asynchronous read operation that was started with a call to BeginRead(Byte[], Int32, Int32, AsyncCallback, Object).

EndWrite(IAsyncResult)

BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object) の呼び出しで開始された、非同期の書き込み操作を終了します。Ends an asynchronous write operation that was started with a call to BeginWrite(Byte[], Int32, Int32, AsyncCallback, Object).

Equals(Object)

指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判定します。Determines whether the specified object is equal to the current object.

(継承元 Object)
Flush()

バッファーに格納されたデータが基になるデバイスに書き込まれるようにします。Causes any buffered data to be written to the underlying device.

FlushAsync()

ストリームに対応するすべてのバッファーを非同期にクリアし、バッファー内のデータを基になるデバイスに書き込みます。Asynchronously clears all buffers for this stream and causes any buffered data to be written to the underlying device.

(継承元 Stream)
FlushAsync(CancellationToken)
GetHashCode()

既定のハッシュ関数として機能します。Serves as the default hash function.

(継承元 Object)
GetLifetimeService()

対象のインスタンスの有効期間ポリシーを制御する、現在の有効期間サービス オブジェクトを取得します。Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(継承元 MarshalByRefObject)
GetType()

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(継承元 Object)
InitializeLifetimeService()

このインスタンスの有効期間ポリシーを制御する有効期間サービス オブジェクトを取得します。Obtains a lifetime service object to control the lifetime policy for this instance.

(継承元 MarshalByRefObject)
MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(継承元 Object)
MemberwiseClone(Boolean)

現在の MarshalByRefObject オブジェクトの簡易コピーを作成します。Creates a shallow copy of the current MarshalByRefObject object.

(継承元 MarshalByRefObject)
ObjectInvariant()

Contract のサポートを提供します。Provides support for a Contract.

(継承元 Stream)
Read(Byte[], Int32, Int32)

このストリームからデータを読み取り、指定した配列に格納します。Reads data from this stream and stores it in the specified array.

Read(Span<Byte>)

派生クラスによってオーバーライドされた場合は、現在のストリームからバイト シーケンスを読み取り、読み取ったバイト数の分だけストリームの位置を進めます。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.

(継承元 Stream)
ReadAsync(Byte[], Int32, Int32)

現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進めます。Asynchronously reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.

(継承元 Stream)
ReadAsync(Byte[], Int32, Int32, CancellationToken)

現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。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.

(継承元 Stream)
ReadAsync(Memory<Byte>, CancellationToken)

現在のストリームからバイト シーケンスを非同期に読み取り、読み取ったバイト数だけストリーム内の位置を進め、キャンセル要求を監視します。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.

(継承元 Stream)
ReadByte()

ストリームから 1 バイトを読み取り、ストリーム内の位置を 1 バイト進めます。ストリームの末尾の場合は -1 を返します。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.

(継承元 Stream)
Seek(Int64, SeekOrigin)

NotSupportedException をスローします。Throws NotSupportedException.

SetLength(Int64)

基になるストリームの長さを設定します。Sets the length of the underlying stream.

ToString()

現在のオブジェクトを表す string を返します。Returns a string that represents the current object.

(継承元 Object)
Write(Byte[], Int32, Int32)

指定したバッファーとオフセットを使用して、基になるストリームに指定した Byte 数を書き込みます。Write the specified number of Bytes to the underlying stream using the specified buffer and offset.

Write(ReadOnlySpan<Byte>)

派生クラスによってオーバーライドされた場合は、現在のストリームにバイト シーケンスを書き込み、書き込んだバイト数の分だけストリームの現在位置を進めます。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.

(継承元 Stream)
WriteAsync(Byte[], Int32, Int32)

現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進めます。Asynchronously writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.

(継承元 Stream)
WriteAsync(Byte[], Int32, Int32, CancellationToken)

現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。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.

(継承元 Stream)
WriteAsync(ReadOnlyMemory<Byte>, CancellationToken)

現在のストリームにバイト シーケンスを非同期に書き込み、書き込んだバイト数だけストリーム内の現在位置を進め、キャンセル要求を監視します。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.

(継承元 Stream)
WriteByte(Byte)

ストリームの現在位置にバイトを書き込み、ストリームの位置を 1 バイトだけ進めます。Writes a byte to the current position in the stream and advances the position within the stream by one byte.

(継承元 Stream)

明示的なインターフェイスの実装

IDisposable.Dispose()

Stream によって使用されているすべてのリソースを解放します。Releases all resources used by the Stream.

(継承元 Stream)

適用対象

こちらもご覧ください