Process.CancelOutputRead メソッドとは？ わかりやすく解説

Weblio 辞書 > コンピュータ > .NET Framework クラス ライブラリ リファレンス > Process.CancelOutputRead メソッドの意味・解説 
.NET Framework クラス ライブラリ リファレンス
索引トップ 用語の索引 ランキング
日本マイクロソフト株式会社日本マイクロソフト株式会社

Process.CancelOutputRead メソッド

メモ : このメソッドは、.NET Framework version 2.0 で新しく追加されたものです。

アプリケーションのリダイレクトされた StandardOutput ストリームで、非同期読み取り操作をキャンセルします。

名前空間: System.Diagnostics
アセンブリ: System (system.dll 内)
構文構文

Visual Basic (宣言)
<ComVisibleAttribute(False)> _
Public Sub CancelOutputRead
Visual Basic (使用法)
Dim instance As Process

instance.CancelOutputRead
C#
[ComVisibleAttribute(false)] 
public void CancelOutputRead ()
C++
[ComVisibleAttribute(false)] 
public:
void CancelOutputRead ()
J#
/** @attribute ComVisibleAttribute(false) */ 
public void CancelOutputRead ()
JScript
ComVisibleAttribute(false) 
public function CancelOutputRead ()
例外例外
例外の種類条件

InvalidOperationException

StandardOutput ストリームでは、非同期読み取り操作が有効になっていません。

解説解説

BeginOutputReadLine は StandardOutput ストリームで非同期読み取り操作を開始し、CancelOutputRead は非同期読み取り操作を終了します。

キャンセル後に非同期読み取り操作を再開するには、BeginOutputReadLine を再度呼び出します。

CancelOutputRead を呼び出すと、StandardOutput に対する進行中の読み取り操作がすべて完了し、イベント ハンドラが無効になります。以降の StandardOutput にリダイレクトされた出力はすべてバッファに保存されます。イベント ハンドラを再度有効化するために BeginOutputReadLine を呼び出すと、保存された出力はイベント ハンドラに送られ、非同期読み取り操作が再開されます。非同期読み取り操作を再開する前にイベント ハンドラを変更する場合は、新しいイベント ハンドラを追加する前に既存のイベント ハンドラを削除する必要があります。 

    // At this point the DataReceivedEventHandler(OutputHandler1) 
    // has executed a CancelOutputRead.

    // Remove the prior event handler.
    process.OutputDataReceived -= 
        new DataReceivedEventHandler(OutputHandler1);

    // Register a new event handler.
    process.OutputDataReceived += 
        new DataReceivedEventHandler(OutputHandler2);

    // Call the corresponding BeginOutputReadLine.
    process.BeginOutputReadLine();
メモメモ

リダイレクトされた StandardOutput ストリームで、非同期読み取り操作と同期読み取り操作を混在させることはできません。Process のリダイレクトされたストリームを非同期モードまたは同期モードで開いた後は、それ以降、そのストリームに対するすべての読み取り操作は同じモードで行う必要があります。StandardOutput での非同期読み取り操作をキャンセルした後で、そのストリームから再度読み取る場合は、BeginOutputReadLine を使用して非同期読み取り操作を再開する必要があります。CancelOutputRead の後に、Read、ReadLine、ReadToEnd など、StandardOutput の同期読み取りメソッドの呼び出しを続けないでください。

使用例使用例

ユーザーが指定した引数を使用して nmake コマンドを開始する例を次に示します。エラー ストリームおよび出力ストリームは非同期で読み取られます。収集されたテキスト行はコンソールに表示され、ログ ファイルに書き込まれます。コマンド出力が指定した行数を超えた場合、非同期読み取り操作はキャンセルされます。

Visual Basic
' Define the namespaces used by this sample.
Imports System
Imports System.Text
Imports System.IO
Imports System.Diagnostics
Imports System.Threading
Imports System.ComponentModel
Imports Microsoft.VisualBasic


Class ProcessNMakeStreamRedirection

   ' Define static variables shared by class methods.
   Private Shared buildLogStream As
 StreamWriter = Nothing
   Private Shared logMutex As
 Mutex = New Mutex()
   Private Shared maxLogLines As
 Integer = 25
   Private Shared currentLogLines As
 Integer = 0
   
   
   Public Shared Sub RedirectNMakeCommandStreams()
      Dim nmakeArguments As String
 = Nothing
      Dim nmakeProcess As Process
      
      ' Get the input nmake command-line arguments.
      Console.WriteLine("Enter the NMake command line arguments"
 + _
          " (@commandfile or /f makefile, etc):")
      Dim inputText As String
 = Console.ReadLine()
      If Not String.IsNullOrEmpty(inputText)
 Then
         nmakeArguments = inputText
      End If
      
      Console.WriteLine("Enter max line limit for log file (default
 is 25):")
      inputText = Console.ReadLine()
      If Not String.IsNullOrEmpty(inputText)
 Then
         If Not Int32.TryParse(inputText, maxLogLines)
 Then
            maxLogLines = 25
         End If
      End If
      Console.WriteLine("Output beyond {0} lines will be ignored.",
 _
          maxLogLines)
      
      ' Initialize the process and its StartInfo properties.
      nmakeProcess = New Process()
      nmakeProcess.StartInfo.FileName = "NMake.exe"
      
      ' Build the nmake command argument list.
      If Not String.IsNullOrEmpty(nmakeArguments)
 Then
         nmakeProcess.StartInfo.Arguments = nmakeArguments
      End If
      
      ' Set UseShellExecute to false for redirection.
      nmakeProcess.StartInfo.UseShellExecute = False
      
      ' Redirect the standard output of the nmake command.  
      ' Read the stream asynchronously using an event handler.
      nmakeProcess.StartInfo.RedirectStandardOutput = True
      AddHandler nmakeProcess.OutputDataReceived, _
                AddressOf NMakeOutputDataHandler
      
      ' Redirect the error output of the nmake command. 
      nmakeProcess.StartInfo.RedirectStandardError = True
      AddHandler nmakeProcess.ErrorDataReceived, _
                AddressOf NMakeErrorDataHandler

      logMutex.WaitOne()

      currentLogLines = 0
    
      ' Write a header to the log file.
      Const buildLogFile As String
 = "NmakeCmd.Txt"
      Try 
          buildLogStream = new StreamWriter(buildLogFile, true)
      Catch e As Exception
          Console.WriteLine("Could not open output file {0}",
 buildLogFile)
          Console.WriteLine("Exception = {0}", e.ToString())
          Console.WriteLine(e.Message)

          buildLogStream = Nothing
      End Try

      If Not buildLogStream Is
 Nothing Then
               
          Console.WriteLine("Nmake output logged to {0}",
 _
              buildLogFile)
    
          buildLogStream.WriteLine()
          buildLogStream.WriteLine(DateTime.Now.ToString())
          
          If Not String.IsNullOrEmpty(nmakeArguments)
 Then
              buildLogStream.Write("Command line = NMake {0}",
 _
                        nmakeArguments)
          Else 
              buildLogStream.Write("Command line = Nmake")
          End If
          
          buildLogStream.WriteLine()
          buildLogStream.Flush()
            
          logMutex.ReleaseMutex()
      
           ' Start the process.
           Console.WriteLine()
           Console.WriteLine("\nStarting Nmake command...")
           Console.WriteLine()
           nmakeProcess.Start()

           ' Start the asynchronous read of the error stream.
           nmakeProcess.BeginErrorReadLine()

           ' Start the asynchronous read of the output stream.
           nmakeProcess.BeginOutputReadLine()
    
           ' Let the nmake command run, collecting the output.
           nmakeProcess.WaitForExit()

           nmakeProcess.Close()
           buildLogStream.Close()
       End If
   End Sub 
   
    Private Shared Sub NMakeOutputDataHandler(sendingProcess
 As Object, _
       outLine As DataReceivedEventArgs)

        ' Collect the output, displaying it to the screen and 
        ' logging it to the output file.  Cancel the read
        ' operation when the maximum line limit is reached.

        If Not String.IsNullOrEmpty(outLine.Data)
 Then
            logMutex.WaitOne()

            currentLogLines = currentLogLines + 1
            If currentLogLines > maxLogLines Then
                
                ' Display the line to the console.
                ' Skip writing the line to the log file.
                Console.WriteLine("StdOut: {0}", outLine.Data)
            Else If currentLogLines = maxLogLines
 Then
                
                LogToFile("StdOut", "<Max
 build log limit reached!>", _
                    true)
    
                ' Stop reading the output streams.
                Dim p As Process = sendingProcess
 
                If Not (p Is
 Nothing) Then
                    p.CancelOutputRead()
                    p.CancelErrorRead()
                End If
            Else 
                ' Write the line to the log file.
                LogToFile("StdOut", outLine.Data,
 true)
            End If

            logMutex.ReleaseMutex()
        End If
 
    End Sub 
   
   Private Shared Sub NMakeErrorDataHandler(sendingProcess
 As Object, _
        errLine As DataReceivedEventArgs)

      ' Collect the error output, displaying it to the screen and 
      ' logging it to the output file.  Cancel the error output
      ' read operation when the maximum line limit is reached.

        If Not String.IsNullOrEmpty(errLine.Data)
 Then
            logMutex.WaitOne()

            currentLogLines = currentLogLines + 1
            If currentLogLines > maxLogLines Then
                
                ' Display the line to the console.
                ' Skip writing the line to the log file.
                Console.WriteLine("StdErr: {0}", errLine.Data)
            Else If currentLogLines = maxLogLines
 Then
                
                LogToFile("StdErr", "<Max
 build log limit reached!>", _
                    true)
    
                ' Stop reading the output streams.
                Dim p As Process = sendingProcess
 
                If Not (p Is
 Nothing) Then
                    p.CancelOutputRead()
                    p.CancelErrorRead()
                End If
            Else 
                ' Write the line to the log file.
                LogToFile("StdErr", errLine.Data,
 true)
            End If

            logMutex.ReleaseMutex()
        End If
 
    End Sub
   
    Private Shared Sub LogToFile(logPrefix
 As String, _
                                logText As String,
 _
                                echoToConsole As String)

        ' Write the specified line to the log file stream.
        Dim logString As StringBuilder = New
 StringBuilder()

        If Not String.IsNullOrEmpty(logPrefix)
 Then
                logString.AppendFormat("{0}> ",
 logPrefix)
        End If

        If Not String.IsNullOrEmpty(logText)
 Then
            logString.Append(logText)
        End If

        If Not buildLogStream Is
 Nothing Then
        
            buildLogStream.WriteLine("[{0}] {1}",
 _
                DateTime.Now.ToString(), logString.ToString())
            buildLogStream.Flush()
         End If
            
         If echoToConsole Then
            Console.WriteLine(logString.ToString())
         End If
  
    End Sub 
End Class
C#
namespace ProcessAsyncStreamSamples
{
    class ProcessNMakeStreamRedirection
    {
        // Define static variables shared by class methods.
        private static StreamWriter buildLogStream
 =null;
        private static Mutex logMutex = new
 Mutex();
        private static int
 maxLogLines = 25;
        private static int
 currentLogLines = 0;

        public static void
 RedirectNMakeCommandStreams()
        {
            String nmakeArguments = null;
            Process nmakeProcess;

            // Get the input nmake command-line arguments.
            Console.WriteLine("Enter the NMake command line arguments "
 +
                "(@commandfile or /f makefile, etc):");
            String inputText = Console.ReadLine();
            if (!String.IsNullOrEmpty(inputText))
            {
                nmakeArguments = inputText;
            }
               
            Console.WriteLine("Enter max line limit for log
 file (default is 25):");
            inputText = Console.ReadLine();
            if (!String.IsNullOrEmpty(inputText))
            {
                if (!Int32.TryParse(inputText, out maxLogLines))
                {
                    maxLogLines = 25;
                }
            }
            Console.WriteLine("Output beyond {0} lines will be ignored."
,
                maxLogLines);

            // Initialize the process and its StartInfo properties.
            nmakeProcess = new Process();
            nmakeProcess.StartInfo.FileName = "NMake.exe";
            
            // Build the nmake command argument list.
            if (!String.IsNullOrEmpty(nmakeArguments))
            {
                nmakeProcess.StartInfo.Arguments = nmakeArguments;
            }

            // Set UseShellExecute to false for redirection.
            nmakeProcess.StartInfo.UseShellExecute = false;

            // Redirect the standard output of the nmake command.  
            // Read the stream asynchronously using an event handler.
            nmakeProcess.StartInfo.RedirectStandardOutput = true;
            nmakeProcess.OutputDataReceived += new DataReceivedEventHandler(NMakeOutputDataHandler);
   
            // Redirect the error output of the nmake command. 
            nmakeProcess.StartInfo.RedirectStandardError = true;
            nmakeProcess.ErrorDataReceived += new DataReceivedEventHandler(NMakeErrorDataHandler);

            logMutex.WaitOne();

            currentLogLines = 0;

            // Write a header to the log file.
            const String buildLogFile = "NmakeCmd.Txt";
            try 
            {
                buildLogStream = new StreamWriter(buildLogFile,
 true);
            }
            catch (Exception e)
            {
                Console.WriteLine("Could not open output file {0}", buildLogFile);
                Console.WriteLine("Exception = {0}", e.ToString());
                Console.WriteLine(e.Message);

                buildLogStream = null;
            }

            if (buildLogStream != null)
            {   
                Console.WriteLine("Nmake output logged to {0}", 
                    buildLogFile);
    
                buildLogStream.WriteLine();
                buildLogStream.WriteLine(DateTime.Now.ToString());
                if (!String.IsNullOrEmpty(nmakeArguments))
                {
                    buildLogStream.Write("Command line = NMake {0}",
                        nmakeArguments);
                }
                else 
                {
                    buildLogStream.Write("Command line = Nmake");
                }
                buildLogStream.WriteLine();
                buildLogStream.Flush();
            
                logMutex.ReleaseMutex();

                // Start the process.
                Console.WriteLine();
                Console.WriteLine("\nStarting Nmake command...");
                Console.WriteLine();
                nmakeProcess.Start();

                // Start the asynchronous read of the error stream.
                nmakeProcess.BeginErrorReadLine();

                // Start the asynchronous read of the output stream.
                nmakeProcess.BeginOutputReadLine();
    
                // Let the nmake command run, collecting the output.
                nmakeProcess.WaitForExit();

                nmakeProcess.Close();
                buildLogStream.Close();
            }
        }

        private static void
 NMakeOutputDataHandler(object sendingProcess, 
            DataReceivedEventArgs outLine)
        {
            // Collect the output, displaying it to the screen and 
            // logging it to the output file.  Cancel the read
            // operation when the maximum line limit is reached.

            if (!String.IsNullOrEmpty(outLine.Data))
            {
                logMutex.WaitOne();

                currentLogLines++;
                if (currentLogLines > maxLogLines)
                {
                    // Display the line to the console.
                    // Skip writing the line to the log file.
                    Console.WriteLine("StdOut: {0}", outLine.Data);
                }
                else if (currentLogLines ==
 maxLogLines)
                {
                    LogToFile("StdOut", "<Max build log limit reached!>",
 
                        true);
    
                    // Stop reading the output streams.
                    Process p = sendingProcess as Process;
                    if (p != null)
                    {
                        p.CancelOutputRead();
                        p.CancelErrorRead();
                    }
                }
                else 
                {
                    // Write the line to the log file.
                    LogToFile("StdOut", outLine.Data, true);
                }
                logMutex.ReleaseMutex();
            }
        }

        private static void
 NMakeErrorDataHandler(object sendingProcess, 
            DataReceivedEventArgs errLine)
        {
            // Collect error output, displaying it to the screen and
 
            // logging it to the output file.  Cancel the error output
            // read operation when the maximum line limit is reached.

            if (!String.IsNullOrEmpty(errLine.Data))
            {
                logMutex.WaitOne();

                currentLogLines++;
                if (currentLogLines > maxLogLines)
                {
                    // Display the error line to the console.
                    // Skip writing the line to the log file.
                    Console.WriteLine("StdErr: {0}", errLine.Data);
                }
                else if (currentLogLines ==
 maxLogLines)
                {
                    LogToFile("StdErr", "<Max build log limit reached!>",
 
                        true);
    
                    // Stop reading the output streams
                    Process p = sendingProcess as Process;
                    if (p != null)
                    {
                        p.CancelErrorRead();
                        p.CancelOutputRead();

                    }
                }
                else 
                {
                    // Write the line to the log file.
                    LogToFile("StdErr", errLine.Data, true);
                }

                logMutex.ReleaseMutex();
            }
        }

        private static void
 LogToFile(String logPrefix, 
            String logText, bool echoToConsole)
        {
            // Write the specified line to the log file stream.
            StringBuilder logString = new StringBuilder();

            if (!String.IsNullOrEmpty(logPrefix))
            {
                logString.AppendFormat("{0}> ", logPrefix);
            }

            if (!String.IsNullOrEmpty(logText))
            {
                logString.Append(logText); 
            }

            if (buildLogStream != null)
            {
                buildLogStream.WriteLine("[{0}] {1}",
                    DateTime.Now.ToString(), logString.ToString());
                buildLogStream.Flush();
            }
            
            if (echoToConsole)
            {
                Console.WriteLine(logString.ToString());
            }
        }
    }
}
C++
ref class ProcessNMakeStreamRedirection
{
private:
   // Define static variables shared by class methods.
   static StreamWriter^ buildLogStream = nullptr;
   static Mutex^ logMutex = gcnew Mutex;
   static int maxLogLines = 25;
   static int currentLogLines = 0;

public:
   static void RedirectNMakeCommandStreams()
   {
      String^ nmakeArguments = nullptr;
      Process^ nmakeProcess;
      
      // Get the input nmake command-line arguments.
      Console::WriteLine( "Enter the NMake command line arguments (@commandfile
 or /f makefile, etc):" );
      String^ inputText = Console::ReadLine();
      if (  !String::IsNullOrEmpty( inputText ) )
      {
         nmakeArguments = inputText;
      }

      Console::WriteLine( "Enter max line limit for log file
 (default is 25):" );
      inputText = Console::ReadLine();
      if (  !String::IsNullOrEmpty( inputText ) )
      {
         if (  !Int32::TryParse( inputText, maxLogLines ) )
         {
            maxLogLines = 25;
         }
      }
      Console::WriteLine( "Output beyond {0} lines will be ignored.",
         maxLogLines.ToString() );
      
      // Initialize the process and its StartInfo properties.
      nmakeProcess = gcnew Process;
      nmakeProcess->StartInfo->FileName = "NMake.exe";
      
      // Build the nmake command argument list.
      if (  !String::IsNullOrEmpty( nmakeArguments ) )
      {
         nmakeProcess->StartInfo->Arguments = nmakeArguments;
      }
      
      // Set UseShellExecute to false for redirection.
      nmakeProcess->StartInfo->UseShellExecute = false;
      
      // Redirect the standard output of the nmake command.  
      // Read the stream asynchronously using an event handler.
      nmakeProcess->StartInfo->RedirectStandardOutput = true;
      nmakeProcess->OutputDataReceived += gcnew DataReceivedEventHandler( NMakeOutputDataHandler
 );
      
      // Redirect the error output of the nmake command. 
      nmakeProcess->StartInfo->RedirectStandardError = true;
      nmakeProcess->ErrorDataReceived += gcnew DataReceivedEventHandler( NMakeErrorDataHandler
 );

      logMutex->WaitOne();

      currentLogLines = 0;
      
      // Write a header to the log file.
      String^ buildLogFile = "NmakeCmd.Txt";
      try
      {
         buildLogStream = gcnew StreamWriter( buildLogFile,true
 );
      }
      catch ( Exception^ e ) 
      {
         Console::WriteLine( "Could not open output file {0}", buildLogFile
 );
         Console::WriteLine( "Exception = {0}", e->ToString() );
         Console::WriteLine( e->Message->ToString() );

         buildLogStream = nullptr;
      }

      if ( buildLogStream != nullptr )
      {
         Console::WriteLine( "Nmake output logged to {0}", buildLogFile
 );

         buildLogStream->WriteLine();
         buildLogStream->WriteLine( DateTime::Now.ToString() );
         if (  !String::IsNullOrEmpty( nmakeArguments ) )
         {
            buildLogStream->Write( "Command line = NMake {0}", nmakeArguments
 );
         }
         else
         {
            buildLogStream->Write( "Command line = Nmake" );
         }
         buildLogStream->WriteLine();
         buildLogStream->Flush();

         logMutex->ReleaseMutex();
         
         // Start the process.
         Console::WriteLine();
         Console::WriteLine( "\nStarting Nmake command" );
         Console::WriteLine();
         nmakeProcess->Start();
         
         // Start the asynchronous read of the output stream.
         nmakeProcess->BeginOutputReadLine();
         
         // Start the asynchronous read of the error stream.
         nmakeProcess->BeginErrorReadLine();
         
         // Let the nmake command run, collecting the output.
         nmakeProcess->WaitForExit();

         nmakeProcess->Close();
         buildLogStream->Close();
      }
   }

private:
   static void NMakeOutputDataHandler( Object^
 sendingProcess,
      DataReceivedEventArgs^ outLine )
   {
      // Collect the output, displaying it to the screen and 
      // logging it to the output file.  Cancel the read
      // operation when the maximum line limit is reached.

      if (  !String::IsNullOrEmpty( outLine->Data ) )
      {
         logMutex->WaitOne();

         currentLogLines++;
         if ( currentLogLines > maxLogLines )
         {
            // Display the line to the console.
            // Skip writing the line to the log file.
            Console::WriteLine( "StdOut: {0}", outLine->Data->ToString()
 );
         }
         else
         if ( currentLogLines == maxLogLines )
         {
            LogToFile( "StdOut", "<Max build log limit reached!>",
 true );
            
            // Stop reading the output streams.
            Process^ p = dynamic_cast<Process^>(sendingProcess);
            if ( p != nullptr )
            {
               p->CancelOutputRead();
               p->CancelErrorRead();
            }
         }
         else
         {
            // Write the line to the log file.
            LogToFile( "StdOut", outLine->Data, true
 );
         }
         logMutex->ReleaseMutex();
      }
   }

   static void NMakeErrorDataHandler( Object^
 sendingProcess,
      DataReceivedEventArgs^ errLine )
   {
      
      // Collect the error output, displaying it to the screen and 
      // logging it to the output file.  Cancel the error output
      // read operation when the maximum line limit is reached.

      if (  !String::IsNullOrEmpty( errLine->Data ) )
      {
         logMutex->WaitOne();

         currentLogLines++;
         if ( currentLogLines > maxLogLines )
         {
            
            // Display the line to the console.
            // Skip writing the line to the log file.
            Console::WriteLine( "StdErr: {0}", errLine->Data->ToString()
 );
         }
         else
         if ( currentLogLines == maxLogLines )
         {
            LogToFile( "StdOut", "<Max build log limit reached!>",
 true );
            
            // Stop reading the output streams.
            Process^ p = dynamic_cast<Process^>(sendingProcess);
            if ( p != nullptr )
            {
               p->CancelOutputRead();
               p->CancelErrorRead();
            }
         }
         else
         {
            // Write the line to the log file.
            LogToFile( "StdErr", errLine->Data, true
 );
         }
         logMutex->ReleaseMutex();
      }
   }

   static void LogToFile( String^ logPrefix,
 String^ logText,
      bool echoToConsole )
   {
      // Write the specified line to the log file stream.
      StringBuilder^ logString = gcnew StringBuilder;

      if (  !String::IsNullOrEmpty( logPrefix ) )
      {
         logString->AppendFormat( "{0}> ", logPrefix );
      }

      if (  !String::IsNullOrEmpty( logText ) )
      {
         logString->Append( logText );
      }

      if ( buildLogStream != nullptr )
      {
         buildLogStream->WriteLine(  "[{0}] {1}",
            DateTime::Now.ToString(), logString->ToString() );
         buildLogStream->Flush();
      }

      if ( echoToConsole )
      {
         Console::WriteLine( logString->ToString() );
      }
   }
};
.NET Framework のセキュリティ.NET Framework のセキュリティ
プラットフォームプラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報バージョン情報
.NET Framework
サポート対象 : 2.0
参照参照
関連項目
Process クラス
Process メンバ
System.Diagnostics 名前空間
BeginOutputReadLine
ProcessStartInfo.RedirectStandardOutput
StandardOutput
OutputDataReceived
DataReceivedEventHandler デリゲート

急上昇のことば

FPSgamer201
ご成婚パレード三色旗掲揚問題
開けゴマ
くぱぁ
ホテル日本閣殺人事件
英和和英テキスト翻訳>> Weblio翻訳
英語⇒日本語日本語⇒英語
  

辞書ショートカット

カテゴリ一覧

全て

＋ ビジネス

＋ 業界用語

＋ コンピュータ

＋ 電車

＋ 自動車・バイク

＋ 船

＋ 工学

＋ 建築・不動産

＋ 学問

＋ 文化

＋ 生活

＋ ヘルスケア

＋ 趣味

＋ スポーツ

＋ 生物

＋ 食品

＋ 人名

＋ 方言

＋ 辞書・百科事典

すべての辞書の索引

あいうえお
かきくけこ
さしすせそ
たちつてと
なにぬねの
はひふへほ
まみむめも
やゆよ
らりるれろ
わをん
がぎぐげご
ざじずぜぞ
だぢづでど
ばびぶべぼ
ぱぴぷぺぽ
ＡＢＣＤＥ
ＦＧＨＩＪ
ＫＬＭＮＯ
ＰＱＲＳＴ
ＵＶＷＸＹ
Ｚ
１２３４５
６７８９０
記号

Weblioのサービス

Process.CancelOutputRead メソッドのお隣キーワード

PrivilegeNotHeldException.GetObjectData メソッド

PrivilegeNotHeldException.PrivilegeName プロパティ

Process.BasePriority プロパティ

Process.BeginErrorReadLine メソッド

Process.BeginOutputReadLine メソッド

Process.CancelErrorRead メソッド

Process.CancelOutputRead メソッド

Process.Close メソッド

Process.CloseMainWindow メソッド

Process.Dispose メソッド

Process.EnableRaisingEvents プロパティ

Process.EnterDebugMode メソッド

Process.ErrorDataReceived イベント

検索ランキング

   

 英語⇒日本語
日本語⇒英語		    


Process.CancelOutputRead メソッドのページの著作権
Weblio 辞書 情報提供元は 参加元一覧 にて確認できます。

   
日本マイクロソフト株式会社日本マイクロソフト株式会社
© 2025 Microsoft.All rights reserved.

©2025 GRAS Group, Inc.RSS