WaitHandle.WaitAll Yöntem

Başvuru

Tanım

Ad Alanı:: System.Threading

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Belirtilen dizideki tüm öğelerin sinyal almasını bekler.

Aşırı Yüklemeler

WaitAll(WaitHandle[], TimeSpan, Boolean)	Belirtilen dizideki tüm öğelerin sinyal almasını bekler, zaman aralığını belirtmek için bir TimeSpan değer kullanarak ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtir.
WaitAll(WaitHandle[], Int32, Boolean)	Belirtilen dizideki tüm öğelerin sinyal almasını bekler; zaman aralığını belirtmek için bir Int32 değer kullanarak ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtir.
WaitAll(WaitHandle[], TimeSpan)	Zaman aralığını belirtmek için bir TimeSpan değer kullanarak belirtilen dizideki tüm öğelerin sinyal almasını bekler.
WaitAll(WaitHandle[], Int32)	Zaman aralığını belirtmek için bir Int32 değer kullanarak belirtilen dizideki tüm öğelerin sinyal almasını bekler.
WaitAll(WaitHandle[])	Belirtilen dizideki tüm öğelerin sinyal almasını bekler.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Belirtilen dizideki tüm öğelerin sinyal almasını bekler, zaman aralığını belirtmek için bir TimeSpan değer kullanarak ve beklemeden önce eşitleme etki alanından çıkıp çıkılmayacağını belirtir.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, TimeSpan timeout, bool exitContext);

public static bool WaitAll (System.Threading.WaitHandle[] waitHandles, TimeSpan timeout, bool exitContext);

static member WaitAll : System.Threading.WaitHandle[] * TimeSpan * bool -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), timeout As TimeSpan, exitContext As Boolean) As Boolean

Parametreler

waitHandles: WaitHandle[]

WaitHandle Geçerli örneğin bekleyeceği nesneleri içeren bir dizi. Bu dizi aynı nesneye birden çok başvuru içeremez.

timeout: TimeSpan

TimeSpan Bekleyebilecek milisaniye sayısını veya süresiz olarak beklemek için -1 milisaniyeyi temsil eden birTimeSpan.

exitContext: Boolean

true beklemeden önce bağlam için eşitleme etki alanından çıkmak (eşitlenmiş bir bağlamdaysa) ve daha sonra yeniden almak; aksi takdirde , false.

Döndürülenler

Boolean

true içindeki waitHandles her öğe bir sinyal aldığında; aksi takdirde false.

Özel durumlar

ArgumentNullException

waitHandles parametresidirnull.

-veya-

Dizideki waitHandles nesnelerden biri veya daha fazlası şeklindedir null.

-veya-

waitHandles öğeleri olmayan bir dizidir ve .NET Framework sürümü 2.0 veya üzeridir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

NotSupportedException

içindeki waitHandles nesne sayısı, sistemin izin verdiklerinden daha fazla.

-veya-

STAThreadAttribute özniteliği geçerli iş parçacığı için iş parçacığı yordamına uygulanır ve waitHandles birden fazla öğe içerir.

ApplicationException

waitHandles öğeleri olmayan bir dizidir ve .NET Framework sürümü 1.0 veya 1.1'dir.

ArgumentOutOfRangeException

timeout , -1 milisaniye dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

-veya-

timeout Int32.MaxValue değerinden büyüktür.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme sonlandırıldı.

InvalidOperationException

Dizi, waitHandles başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucu içerir.

Örnekler

Aşağıdaki kod örneği, iş parçacığı havuzunu kullanarak zaman uyumsuz olarak nasıl oluşturulacağını ve bir dosya grubuna nasıl yazacağını gösterir. Her yazma işlemi bir iş öğesi olarak kuyruğa alınıyor ve tamamlandığında sinyal veriyor. Ana iş parçacığı tüm öğelerin sinyal vermesini bekler ve sonra çıkar.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Maintain state to pass to WriteToFile.
ref class State
{
public:
   String^ fileName;
   array<Byte>^byteArray;
   ManualResetEvent^ manualEvent;
   State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent )
      : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent )
   {}

};

ref class Writer
{
private:
   static int workItemCount = 0;
   Writer(){}


public:
   static void WriteToFile( Object^ state )
   {
      int workItemNumber = workItemCount;
      Interlocked::Increment( workItemCount );
      Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() );
      State^ stateInfo = dynamic_cast<State^>(state);
      FileStream^ fileWriter;
      
      // Create and write to the file.
      try
      {
         fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create );
         fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length );
      }
      finally
      {
         if ( fileWriter != nullptr )
         {
            fileWriter->Close();
         }
         
         // Signal main() that the work item has finished.
         Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() );
         stateInfo->manualEvent->Set();
      }

   }

};

int main()
{
   const int numberOfFiles = 5;
   String^ dirName =  "C:\\TestTest";
   String^ fileName;
   array<Byte>^byteArray;
   Random^ randomGenerator = gcnew Random;
   array<ManualResetEvent^>^manualEvents = gcnew array<ManualResetEvent^>(numberOfFiles);
   State^ stateInfo;
   if (  !Directory::Exists( dirName ) )
   {
      Directory::CreateDirectory( dirName );
   }

   
   // Queue the work items that create and write to the files.
   for ( int i = 0; i < numberOfFiles; i++ )
   {
      fileName = String::Concat( dirName,  "\\Test", ((i)).ToString(),  ".dat" );
      
      // Create random data to write to the file.
      byteArray = gcnew array<Byte>(1000000);
      randomGenerator->NextBytes( byteArray );
      manualEvents[ i ] = gcnew ManualResetEvent( false );
      stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] );
      ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &Writer::WriteToFile ), stateInfo );

   }
   
   // Since ThreadPool threads are background threads, 
   // wait for the work items to signal before exiting.
   if ( WaitHandle::WaitAll( manualEvents, TimeSpan(0,0,5), false ) )
   {
      Console::WriteLine( "Files written - main exiting." );
   }
   else
   {
      
      // The wait operation times out.
      Console::WriteLine( "Error writing files - main exiting." );
   }
}

using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;

class Test
{
    static void Main()
    {
        const int numberOfFiles = 5;
        string dirName = @"C:\TestTest";
        string fileName;

        byte[] byteArray;
        Random randomGenerator = new Random();

        ManualResetEvent[] manualEvents = 
            new ManualResetEvent[numberOfFiles];
        State stateInfo;

        if(!Directory.Exists(dirName))
        {
            Directory.CreateDirectory(dirName);
        }

        // Queue the work items that create and write to the files.
        for(int i = 0; i < numberOfFiles; i++)
        {
            fileName = string.Concat(
                dirName, @"\Test", i.ToString(), ".dat");

            // Create random data to write to the file.
            byteArray = new byte[1000000];
            randomGenerator.NextBytes(byteArray);

            manualEvents[i] = new ManualResetEvent(false);

            stateInfo = 
                new State(fileName, byteArray, manualEvents[i]);

            ThreadPool.QueueUserWorkItem(new WaitCallback(
                Writer.WriteToFile), stateInfo);
        }
    
        // Since ThreadPool threads are background threads, 
        // wait for the work items to signal before exiting.
        if(WaitHandle.WaitAll(
            manualEvents, new TimeSpan(0, 0, 5), false))
        {
            Console.WriteLine("Files written - main exiting.");
        }
        else
        {
            // The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.");
        }
    }
}

// Maintain state to pass to WriteToFile.
class State
{
    public string fileName;
    public byte[] byteArray;
    public ManualResetEvent manualEvent;

    public State(string fileName, byte[] byteArray, 
        ManualResetEvent manualEvent)
    {
        this.fileName = fileName;
        this.byteArray = byteArray;
        this.manualEvent = manualEvent;
    }
}

class Writer
{
    static int workItemCount = 0;
    Writer() {}

    public static void WriteToFile(object state)
    {
        int workItemNumber = workItemCount;
        Interlocked.Increment(ref workItemCount);
        Console.WriteLine("Starting work item {0}.",
            workItemNumber.ToString());
        State stateInfo = (State)state;
        FileStream fileWriter = null;

        // Create and write to the file.
        try
        {
            fileWriter = new FileStream(
                stateInfo.fileName, FileMode.Create);
            fileWriter.Write(stateInfo.byteArray, 
                0, stateInfo.byteArray.Length);
        }
        finally
        {
            if(fileWriter != null)
            {
                fileWriter.Close();
            }

            // Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", 
                workItemNumber.ToString());
            stateInfo.manualEvent.Set();
        }
    }
}

Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Test

    ' WaitHandle.WaitAll requires a multithreaded apartment 
    ' when using multiple wait handles.
    <MTAThreadAttribute> _
    Shared Sub Main()
        Const numberOfFiles As Integer = 5
        Dim dirName As String = "C:\TestTest"
        Dim fileName As String 

        Dim byteArray() As Byte 
        Dim randomGenerator As New Random()

        Dim manualEvents(numberOfFiles - 1) As ManualResetEvent
        Dim stateInfo As State 

        If Directory.Exists(dirName) <> True Then
            Directory.CreateDirectory(dirName)
        End If

        ' Queue the work items that create and write to the files.
        For i As Integer = 0 To numberOfFiles - 1
            fileName = String.Concat( _
                dirName, "\Test", i.ToString(), ".dat")

            ' Create random data to write to the file.
            byteArray = New Byte(1000000){}
            randomGenerator.NextBytes(byteArray)

            manualEvents(i) = New ManualResetEvent(false)

            stateInfo = _ 
                New State(fileName, byteArray, manualEvents(i))

            ThreadPool.QueueUserWorkItem(AddressOf _
                Writer.WriteToFile, stateInfo)
        Next i
    
        ' Since ThreadPool threads are background threads, 
        ' wait for the work items to signal before exiting.
        If WaitHandle.WaitAll( _
            manualEvents, New TimeSpan(0, 0, 5), false) = True  Then

            Console.WriteLine("Files written - main exiting.")
        Else
        
            ' The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.")
        End If
    End Sub

End Class
 
' Maintain state to pass to WriteToFile.
Public Class State

    Public fileName As String
    Public byteArray As Byte()
    Public manualEvent As ManualResetEvent

    Sub New(fileName As String, byteArray() As Byte, _
        manualEvent As ManualResetEvent)
    
        Me.fileName = fileName
        Me.byteArray = byteArray
        Me.manualEvent = manualEvent
    End Sub

End Class

Public Class Writer

    Private Sub New()
    End Sub

    Shared workItemCount As Integer = 0

    Shared Sub WriteToFile(state As Object)
        Dim workItemNumber As Integer = workItemCount
        Interlocked.Increment(workItemCount)
        Console.WriteLine("Starting work item {0}.", _
            workItemNumber.ToString())
        Dim stateInfo As State = CType(state, State)
        Dim fileWriter As FileStream = Nothing

        ' Create and write to the file.
        Try
            fileWriter = New FileStream( _
                stateInfo.fileName, FileMode.Create)
            fileWriter.Write(stateInfo.byteArray, _
                0, stateInfo.byteArray.Length)
        Finally
            If Not fileWriter Is Nothing Then
                fileWriter.Close()
            End If

            ' Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", _
                workItemNumber.ToString())
            stateInfo.manualEvent.Set()
        End Try
    End Sub

End Class

Açıklamalar

Sıfır ise timeout , yöntemi engellemez. Bekleme tutamaçlarının durumunu test eder ve hemen döndürür.

Bir mutex terk edilirse, bir AbandonedMutexException atılır. Terk edilmiş bir mutex genellikle ciddi bir kodlama hatasına işaret eder. Sistem genelinde bir mutex söz konusu olduğunda, bir uygulamanın aniden sonlandırıldığını gösterebilir (örneğin, Windows Görev Yöneticisi kullanılarak). Özel durum, hata ayıklama için yararlı bilgiler içerir.

WaitAll yöntemi, bekleme sonlandırıldığında döndürür; bu da tüm tanıtıcılara sinyal verildiği veya zaman aşımı oluştuğu anlamına gelir. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizi yinelenenler içeriyorsa, çağrı başarısız olur.

Not

yöntemi WaitAll , durumundaki iş parçacıklarında STA desteklenmez.

için timeout en büyük değer değeridir Int32.MaxValue.

Bağlamdan çıkma

Bu exitContext yöntem, bilinmeyen yönetilen bağlamın içinden çağrılmadığı sürece parametresinin hiçbir etkisi olmaz. İş parçacığınız öğesinden ContextBoundObjecttüretilen bir sınıfın örneğine yönelik bir çağrının içindeyse yönetilen bağlamda hiçbir zaman uyumsuz olabilir. şu anda gibi Stringöğesinden ContextBoundObjecttüretilmiş olmayan bir sınıfta bir yöntem yürütüyor olsanız bile, geçerli uygulama etki alanındaki yığınınızda bir varsaContextBoundObject, varsayılan olmayan bir bağlamda olabilirsiniz.

Kodunuz bilinmeyen bir bağlamda yürütülürken öğesinin belirtilmesi trueexitContext , iş parçacığının bu yöntemi yürütmeden önce bilinmeyen yönetilen bağlamdan (varsayılan bağlama geçiş için) çıkmasını sağlar. İş parçacığı, bu yöntem çağrısı tamamlandıktan sonra özgün bilinmeyen bağlama döner.

Bağlama bağlı sınıf özniteliğine sahip olduğunda bağlamdan SynchronizationAttribute çıkmak yararlı olabilir. Bu durumda, sınıfın üyelerine yapılan tüm çağrılar otomatik olarak eşitlenir ve eşitleme etki alanı sınıfın kod gövdesinin tamamıdır. Bir üyenin çağrı yığınındaki kod bu yöntemi çağırır ve öğesini exitContextbelirtirsetrue, iş parçacığı eşitleme etki alanından çıkar ve bu da nesnenin herhangi bir üyesine yapılan çağrıda engellenen bir iş parçacığının devam etmesini sağlar. Bu yöntem döndürdüğünde, çağrıyı yapan iş parçacığının eşitleme etki alanını yeniden eklemek için beklemesi gerekir.

Şunlara uygulanır

WaitAll(WaitHandle[], Int32, Boolean)

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Belirtilen dizideki tüm öğelerin sinyal almasını bekler; zaman aralığını belirtmek için bir Int32 değer kullanarak ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, int millisecondsTimeout, bool exitContext);

public static bool WaitAll (System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout, bool exitContext);

static member WaitAll : System.Threading.WaitHandle[] * int * bool -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Parametreler

waitHandles: WaitHandle[]

WaitHandle Geçerli örneğin bekleyeceği nesneleri içeren bir dizi. Bu dizi aynı nesneye (yinelenenler) birden çok başvuru içeremez.

millisecondsTimeout: Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak bekleniyor.

exitContext: Boolean

true beklemeden önce bağlam için eşitleme etki alanından çıkmak (eşitlenmiş bir bağlamdaysa) ve daha sonra yeniden almak; aksi takdirde , false.

Döndürülenler

Boolean

true içindeki waitHandles her öğe bir sinyal aldığında; aksi takdirde , false.

Özel durumlar

ArgumentNullException

waitHandles parametresidirnull.

-veya-

Dizideki waitHandles nesnelerden biri veya daha fazlası şeklindedir null.

-veya-

waitHandles öğeleri olmayan bir dizidir ve .NET Framework sürümü 2.0 veya üzeridir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

NotSupportedException

içindeki waitHandles nesne sayısı, sistemin izin verdiklerinden daha fazla.

-veya-

Geçerli iş parçacığı durumunda STA ve waitHandles birden fazla öğe içeriyor.

ApplicationException

waitHandles öğeleri olmayan bir dizidir ve .NET Framework sürümü 1.0 veya 1.1'dir.

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Dizi, waitHandles başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucu içerir.

Örnekler

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

// Maintain state to pass to WriteToFile.
ref class State
{
public:
   String^ fileName;
   array<Byte>^byteArray;
   ManualResetEvent^ manualEvent;
   State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent )
      : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent )
   {}

};

ref class Writer
{
private:
   static int workItemCount = 0;
   Writer(){}


public:
   static void WriteToFile( Object^ state )
   {
      int workItemNumber = workItemCount;
      Interlocked::Increment( workItemCount );
      Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() );
      State^ stateInfo = dynamic_cast<State^>(state);
      FileStream^ fileWriter;
      
      // Create and write to the file.
      try
      {
         fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create );
         fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length );
      }
      finally
      {
         if ( fileWriter != nullptr )
         {
            fileWriter->Close();
         }
         
         // Signal main() that the work item has finished.
         Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() );
         stateInfo->manualEvent->Set();
      }

   }

};

int main()
{
   const int numberOfFiles = 5;
   String^ dirName =  "C:\\TestTest";
   String^ fileName;
   array<Byte>^byteArray;
   Random^ randomGenerator = gcnew Random;
   array<ManualResetEvent^>^manualEvents = gcnew array<ManualResetEvent^>(numberOfFiles);
   State^ stateInfo;
   if (  !Directory::Exists( dirName ) )
   {
      Directory::CreateDirectory( dirName );
   }

   
   // Queue the work items that create and write to the files.
   for ( int i = 0; i < numberOfFiles; i++ )
   {
      fileName = String::Concat( dirName,  "\\Test", ((i)).ToString(),  ".dat" );
      
      // Create random data to write to the file.
      byteArray = gcnew array<Byte>(1000000);
      randomGenerator->NextBytes( byteArray );
      manualEvents[ i ] = gcnew ManualResetEvent( false );
      stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] );
      ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &Writer::WriteToFile ), stateInfo );

   }
   
   // Since ThreadPool threads are background threads, 
   // wait for the work items to signal before exiting.
   if ( WaitHandle::WaitAll( manualEvents, 5000, false ) )
   {
      Console::WriteLine( "Files written - main exiting." );
   }
   else
   {
      
      // The wait operation times out.
      Console::WriteLine( "Error writing files - main exiting." );
   }
}

using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;

class Test
{
    static void Main()
    {
        const int numberOfFiles = 5;
        string dirName = @"C:\TestTest";
        string fileName;

        byte[] byteArray;
        Random randomGenerator = new Random();

        ManualResetEvent[] manualEvents = 
            new ManualResetEvent[numberOfFiles];
        State stateInfo;

        if(!Directory.Exists(dirName))
        {
            Directory.CreateDirectory(dirName);
        }

        // Queue the work items that create and write to the files.
        for(int i = 0; i < numberOfFiles; i++)
        {
            fileName = string.Concat(
                dirName, @"\Test", i.ToString(), ".dat");

            // Create random data to write to the file.
            byteArray = new byte[1000000];
            randomGenerator.NextBytes(byteArray);

            manualEvents[i] = new ManualResetEvent(false);

            stateInfo = 
                new State(fileName, byteArray, manualEvents[i]);

            ThreadPool.QueueUserWorkItem(new WaitCallback(
                Writer.WriteToFile), stateInfo);
        }
    
        // Since ThreadPool threads are background threads, 
        // wait for the work items to signal before exiting.
        if(WaitHandle.WaitAll(manualEvents, 5000, false))
        {
            Console.WriteLine("Files written - main exiting.");
        }
        else
        {
            // The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.");
        }
    }
}

// Maintain state to pass to WriteToFile.
class State
{
    public string fileName;
    public byte[] byteArray;
    public ManualResetEvent manualEvent;

    public State(string fileName, byte[] byteArray, 
        ManualResetEvent manualEvent)
    {
        this.fileName = fileName;
        this.byteArray = byteArray;
        this.manualEvent = manualEvent;
    }
}

class Writer
{
    static int workItemCount = 0;
    Writer() {}

    public static void WriteToFile(object state)
    {
        int workItemNumber = workItemCount;
        Interlocked.Increment(ref workItemCount);
        Console.WriteLine("Starting work item {0}.",
            workItemNumber.ToString());
        State stateInfo = (State)state;
        FileStream fileWriter = null;

        // Create and write to the file.
        try
        {
            fileWriter = new FileStream(
                stateInfo.fileName, FileMode.Create);
            fileWriter.Write(stateInfo.byteArray, 
                0, stateInfo.byteArray.Length);
        }
        finally
        {
            if(fileWriter != null)
            {
                fileWriter.Close();
            }

            // Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", 
                workItemNumber.ToString());
            stateInfo.manualEvent.Set();
        }
    }
}

Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Test

    ' WaitHandle.WaitAll requires a multithreaded apartment 
    ' when using multiple wait handles.
    <MTAThreadAttribute> _
    Shared Sub Main()
        Const numberOfFiles As Integer = 5
        Dim dirName As String = "C:\TestTest"
        Dim fileName As String 

        Dim byteArray() As Byte 
        Dim randomGenerator As New Random()

        Dim manualEvents(numberOfFiles - 1) As ManualResetEvent
        Dim stateInfo As State 

        If Directory.Exists(dirName) <> True Then
            Directory.CreateDirectory(dirName)
        End If

        ' Queue the work items that create and write to the files.
        For i As Integer = 0 To numberOfFiles - 1
            fileName = String.Concat( _
                dirName, "\Test", i.ToString(), ".dat")

            ' Create random data to write to the file.
            byteArray = New Byte(1000000){}
            randomGenerator.NextBytes(byteArray)

            manualEvents(i) = New ManualResetEvent(false)

            stateInfo = _ 
                New State(fileName, byteArray, manualEvents(i))

            ThreadPool.QueueUserWorkItem(AddressOf _
                Writer.WriteToFile, stateInfo)
        Next i
    
        ' Since ThreadPool threads are background threads, 
        ' wait for the work items to signal before exiting.
        If WaitHandle.WaitAll(manualEvents, 5000, false) = True  Then

            Console.WriteLine("Files written - main exiting.")
        Else
        
            ' The wait operation times out.
            Console.WriteLine("Error writing files - main exiting.")
        End If
    End Sub

End Class
 
' Maintain state to pass to WriteToFile.
Public Class State

    Public fileName As String
    Public byteArray As Byte()
    Public manualEvent As ManualResetEvent

    Sub New(fileName As String, byteArray() As Byte, _
        manualEvent As ManualResetEvent)
    
        Me.fileName = fileName
        Me.byteArray = byteArray
        Me.manualEvent = manualEvent
    End Sub

End Class

Public Class Writer

    Private Sub New()
    End Sub

    Shared workItemCount As Integer = 0

    Shared Sub WriteToFile(state As Object)
        Dim workItemNumber As Integer = workItemCount
        Interlocked.Increment(workItemCount)
        Console.WriteLine("Starting work item {0}.", _
            workItemNumber.ToString())
        Dim stateInfo As State = CType(state, State)
        Dim fileWriter As FileStream = Nothing

        ' Create and write to the file.
        Try
            fileWriter = New FileStream( _
                stateInfo.fileName, FileMode.Create)
            fileWriter.Write(stateInfo.byteArray, _
                0, stateInfo.byteArray.Length)
        Finally
            If Not fileWriter Is Nothing Then
                fileWriter.Close()
            End If

            ' Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", _
                workItemNumber.ToString())
            stateInfo.manualEvent.Set()
        End Try
    End Sub

End Class

Açıklamalar

Sıfır ise millisecondsTimeout , yöntemi engellemez. Bekleme tutamaçlarının durumunu test eder ve hemen döndürür.

Yöntemi WaitAll , bekleme sona erdiğinde döndürür; bu da tüm tanıtıcılara sinyal verildiğinde veya zaman aşımı oluştuğunda anlamına gelir. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizide yinelenenler varsa, çağrısı ile DuplicateWaitObjectExceptionbaşarısız olur.

Not

yöntemi WaitAll , durumundaki iş parçacıklarında STA desteklenmez.

Bağlamdan çıkma

Bağlama bağlı sınıf özniteliğine sahip olduğunda bağlamdan SynchronizationAttribute çıkmak yararlı olabilir. Bu durumda, sınıfın üyelerine yapılan tüm çağrılar otomatik olarak eşitlenir ve eşitleme etki alanı sınıfın kod gövdesinin tamamıdır. Bir üyenin çağrı yığınındaki kod bu yöntemi çağırır ve öğesini exitContextbelirtirsetrue, iş parçacığı eşitleme etki alanından çıkar ve bu da nesnenin herhangi bir üyesine yapılan çağrıda engellenen bir iş parçacığının devam etmesini sağlar. Bu yöntem döndürdüğünde, eşitleme etki alanını yeniden eklemek için çağrıyı yapan iş parçacığının beklemesi gerekir.

Şunlara uygulanır

WaitAll(WaitHandle[], TimeSpan)

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Zaman aralığını belirtmek için bir TimeSpan değer kullanarak belirtilen dizideki tüm öğelerin sinyal almasını bekler.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, TimeSpan timeout);

public static bool WaitAll (System.Threading.WaitHandle[] waitHandles, TimeSpan timeout);

static member WaitAll : System.Threading.WaitHandle[] * TimeSpan -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), timeout As TimeSpan) As Boolean

Parametreler

waitHandles: WaitHandle[]

WaitHandle Geçerli örneğin bekleyeceği nesneleri içeren bir dizi. Bu dizi aynı nesneye birden çok başvuru içeremez.

timeout: TimeSpan

TimeSpan Bekleyebilecek milisaniye sayısını veya süresiz olarak beklemek için -1 milisaniyeyi temsil eden birTimeSpan.

Döndürülenler

Boolean

true içindeki waitHandles her öğe bir sinyal aldığında; aksi takdirde , false.

Özel durumlar

ArgumentNullException

waitHandles parametresidirnull.

-veya-

Dizideki waitHandles nesnelerden biri veya daha fazlası şeklindedir null.

-veya-

waitHandles , öğe içermeyen bir dizidir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

Not: Windows Mağazası uygulamaları için .NET'te veya Taşınabilir Sınıf Kitaplığı'nda bunun yerine temel sınıf özel durumunu ArgumentExceptionyakalayın.

NotSupportedException

içindeki waitHandles nesne sayısı, sistemin izin sayısından fazladır.

-veya-

Geçerli iş parçacığı durumunda STA ve waitHandles birden fazla öğe içeriyor.

ArgumentOutOfRangeException

timeout , -1 milisaniye dışında, sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

-veya-

timeout Int32.MaxValue değerinden büyüktür.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme sonlandırıldı.

InvalidOperationException

Dizi, waitHandles başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucu içerir.

Açıklamalar

Sıfır ise timeout , yöntemi engellemez. Bekleme tutamaçlarının durumunu test eder ve hemen döndürür.

WaitAll yöntemi, bekleme sonlandırıldığında döndürür; bu da tüm tanıtıcıların sinyal aldığı veya zaman aşımı oluştuğu anlamına gelir. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizi yinelenenler içeriyorsa, çağrı başarısız olur.

Not

yöntemi WaitAll , durumundaki iş parçacıklarında STA desteklenmez.

için timeout en büyük değer: Int32.MaxValue.

Bu yöntem aşırı yüklemesini çağırmak, aşırı yüklemeyi çağırmak WaitAll(WaitHandle[], TimeSpan, Boolean) ve için belirtmekle falseexitContextaynıdır.

Şunlara uygulanır

WaitAll(WaitHandle[], Int32)

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Zaman aralığını belirtmek için bir Int32 değer kullanarak belirtilen dizideki tüm öğelerin sinyal almasını bekler.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles, int millisecondsTimeout);

public static bool WaitAll (System.Threading.WaitHandle[] waitHandles, int millisecondsTimeout);

static member WaitAll : System.Threading.WaitHandle[] * int -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle(), millisecondsTimeout As Integer) As Boolean

Parametreler

waitHandles: WaitHandle[]

WaitHandle Geçerli örneğin bekleyeceği nesneleri içeren bir dizi. Bu dizi aynı nesneye birden çok başvuru içeremez (yinelemeler).

millisecondsTimeout: Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak bekleniyor.

Döndürülenler

Boolean

true içindeki waitHandles her öğe bir sinyal aldığında; aksi takdirde , false.

Özel durumlar

ArgumentNullException

waitHandles parametresidirnull.

-veya-

Dizideki waitHandles nesnelerden biri veya daha fazlası şeklindedir null.

-veya-

waitHandles , öğe içermeyen bir dizidir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

Not: Windows Mağazası uygulamaları için .NET'te veya Taşınabilir Sınıf Kitaplığı'nda bunun yerine temel sınıf özel durumunu ArgumentExceptionyakalayın.

NotSupportedException

içindeki waitHandles nesne sayısı, sistemin izin sayısından fazladır.

-veya-

Geçerli iş parçacığı durumunda STA ve waitHandles birden fazla öğe içeriyor.

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında sonsuz bir zaman aşımını temsil eden negatif bir sayıdır.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme tamamlandı.

InvalidOperationException

Dizi, waitHandles başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucu içerir.

Açıklamalar

Sıfır ise millisecondsTimeout , yöntemi engellemez. Bekleme tutamaçlarının durumunu test eder ve hemen döndürür.

yöntemi WaitAll , bekleme sona erdiğinde döndürür, yani tüm tanıtıcılar sinyal verildiğinde veya zaman aşımı olduğunda. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizide yinelenenler varsa, çağrısı ile DuplicateWaitObjectExceptionbaşarısız olur.

Not

yöntemi WaitAll , durumundaki iş parçacıklarında STA desteklenmez.

Bu yöntem aşırı yüklemesini çağırmak, aşırı yüklemeyi çağırmak WaitAll(WaitHandle[], Int32, Boolean) ve için belirtmekle falseexitContextaynıdır.

Şunlara uygulanır

WaitAll(WaitHandle[])

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Kaynak:: WaitHandle.cs

Belirtilen dizideki tüm öğelerin sinyal almasını bekler.

public:
 static bool WaitAll(cli::array <System::Threading::WaitHandle ^> ^ waitHandles);

public static bool WaitAll (System.Threading.WaitHandle[] waitHandles);

static member WaitAll : System.Threading.WaitHandle[] -> bool

Public Shared Function WaitAll (waitHandles As WaitHandle()) As Boolean

Parametreler

waitHandles: WaitHandle[]

WaitHandle Geçerli örneğin bekleyeceği nesneleri içeren bir dizi. Bu dizi aynı nesneye birden çok başvuru içeremez.

Döndürülenler

Boolean

true içindeki waitHandles her öğe bir sinyal aldığında; aksi takdirde yöntem hiçbir zaman döndürmez.

Özel durumlar

ArgumentNullException

waitHandles parametresidirnull. -veya-

Dizideki waitHandles nesnelerden biri veya daha fazlası şeklindedir null.

-veya-

waitHandles öğe içermeyen bir dizidir ve .NET Framework sürümü 2.0 veya üzeridir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

Not: Windows Mağazası uygulamaları için .NET'te veya Taşınabilir Sınıf Kitaplığı'nda bunun yerine temel sınıf özel durumunu ArgumentExceptionyakalayın.

NotSupportedException

içindeki waitHandles nesne sayısı, sistemin izin sayısından fazladır.

-veya-

Geçerli iş parçacığı durumunda STA ve waitHandles birden fazla öğe içeriyor.

ApplicationException

waitHandles öğeleri olmayan bir dizidir ve .NET Framework sürümü 1.0 veya 1.1'dir.

AbandonedMutexException

Bir iş parçacığı bir mutex serbest bırakmadan çıktığı için bekleme sonlandırıldı.

InvalidOperationException

Dizi, waitHandles başka bir uygulama etki alanındaki için saydam bir WaitHandle ara sunucu içerir.

Örnekler

Aşağıdaki kod örneğinde, iş parçacığı havuzunu kullanarak zaman uyumsuz olarak dosya grubu oluşturma ve dosya grubuna yazma işlemi gösterilmektedir. Her yazma işlemi bir iş öğesi olarak kuyruğa alınır ve bittiğinde sinyal gönderir. Ana iş parçacığı tüm öğelerin sinyal göndermesini bekler ve sonra çıkar.

using namespace System;
using namespace System::IO;
using namespace System::Security::Permissions;
using namespace System::Threading;

ref class State
{
public:
   String^ fileName;
   array<Byte>^byteArray;
   ManualResetEvent^ manualEvent;
   State( String^ fileName, array<Byte>^byteArray, ManualResetEvent^ manualEvent )
      : fileName( fileName ), byteArray( byteArray ), manualEvent( manualEvent )
   {}

};

ref class Writer
{
private:
   static int workItemCount = 0;
   Writer(){}


public:
   static void WriteToFile( Object^ state )
   {
      int workItemNumber = workItemCount;
      Interlocked::Increment( workItemCount );
      Console::WriteLine( "Starting work item {0}.", workItemNumber.ToString() );
      State^ stateInfo = dynamic_cast<State^>(state);
      FileStream^ fileWriter;
      
      // Create and write to the file.
      try
      {
         fileWriter = gcnew FileStream( stateInfo->fileName,FileMode::Create );
         fileWriter->Write( stateInfo->byteArray, 0, stateInfo->byteArray->Length );
      }
      finally
      {
         if ( fileWriter != nullptr )
         {
            fileWriter->Close();
         }
         
         // Signal main() that the work item has finished.
         Console::WriteLine( "Ending work item {0}.", workItemNumber.ToString() );
         stateInfo->manualEvent->Set();
      }

   }

};

void main()
{
   const int numberOfFiles = 5;
   String^ dirName =  "C:\\TestTest";
   String^ fileName;
   array<Byte>^byteArray;
   Random^ randomGenerator = gcnew Random;
   array<ManualResetEvent^>^manualEvents = gcnew array<ManualResetEvent^>(numberOfFiles);
   State^ stateInfo;
   if (  !Directory::Exists( dirName ) )
   {
      Directory::CreateDirectory( dirName );
   }

   
   // Queue the work items that create and write to the files.
   for ( int i = 0; i < numberOfFiles; i++ )
   {
      fileName = String::Concat( dirName,  "\\Test", ((i)).ToString(),  ".dat" );
      
      // Create random data to write to the file.
      byteArray = gcnew array<Byte>(1000000);
      randomGenerator->NextBytes( byteArray );
      manualEvents[ i ] = gcnew ManualResetEvent( false );
      stateInfo = gcnew State( fileName,byteArray,manualEvents[ i ] );
      ThreadPool::QueueUserWorkItem( gcnew WaitCallback( &Writer::WriteToFile ), stateInfo );

   }
   
   // Since ThreadPool threads are background threads, 
   // wait for the work items to signal before exiting.
   WaitHandle::WaitAll( manualEvents );
   Console::WriteLine( "Files written - main exiting." );
}

using System;
using System.IO;
using System.Security.Permissions;
using System.Threading;

class Test
{
    static void Main()
    {
        const int numberOfFiles = 5;
        string dirName = @"C:\TestTest";
        string fileName;

        byte[] byteArray;
        Random randomGenerator = new Random();

        ManualResetEvent[] manualEvents = 
            new ManualResetEvent[numberOfFiles];
        State stateInfo;

        if(!Directory.Exists(dirName))
        {
            Directory.CreateDirectory(dirName);
        }

        // Queue the work items that create and write to the files.
        for(int i = 0; i < numberOfFiles; i++)
        {
            fileName = string.Concat(
                dirName, @"\Test", i.ToString(), ".dat");

            // Create random data to write to the file.
            byteArray = new byte[1000000];
            randomGenerator.NextBytes(byteArray);

            manualEvents[i] = new ManualResetEvent(false);

            stateInfo = 
                new State(fileName, byteArray, manualEvents[i]);

            ThreadPool.QueueUserWorkItem(new WaitCallback(
                Writer.WriteToFile), stateInfo);
        }
    
        // Since ThreadPool threads are background threads, 
        // wait for the work items to signal before exiting.
        WaitHandle.WaitAll(manualEvents);
        Console.WriteLine("Files written - main exiting.");
    }
}

// Maintain state to pass to WriteToFile.
class State
{
    public string fileName;
    public byte[] byteArray;
    public ManualResetEvent manualEvent;

    public State(string fileName, byte[] byteArray, 
        ManualResetEvent manualEvent)
    {
        this.fileName = fileName;
        this.byteArray = byteArray;
        this.manualEvent = manualEvent;
    }
}

class Writer
{
    static int workItemCount = 0;
    Writer() {}

    public static void WriteToFile(object state)
    {
        int workItemNumber = workItemCount;
        Interlocked.Increment(ref workItemCount);
        Console.WriteLine("Starting work item {0}.",
            workItemNumber.ToString());
        State stateInfo = (State)state;
        FileStream fileWriter = null;

        // Create and write to the file.
        try
        {
            fileWriter = new FileStream(
                stateInfo.fileName, FileMode.Create);
            fileWriter.Write(stateInfo.byteArray, 
                0, stateInfo.byteArray.Length);
        }
        finally
        {
            if(fileWriter != null)
            {
                fileWriter.Close();
            }

            // Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", 
                workItemNumber.ToString());
            stateInfo.manualEvent.Set();
        }
    }
}

Imports System.IO
Imports System.Security.Permissions
Imports System.Threading

Public Class Test

    ' WaitHandle.WaitAll requires a multithreaded apartment 
    ' when using multiple wait handles.
    <MTAThreadAttribute> _
    Shared Sub Main()
        Const numberOfFiles As Integer = 5
        Dim dirName As String = "C:\TestTest"
        Dim fileName As String 

        Dim byteArray() As Byte 
        Dim randomGenerator As New Random()

        Dim manualEvents(numberOfFiles - 1) As ManualResetEvent
        Dim stateInfo As State 

        If Directory.Exists(dirName) <> True Then
            Directory.CreateDirectory(dirName)
        End If

        ' Queue the work items that create and write to the files.
        For i As Integer = 0 To numberOfFiles - 1
            fileName = String.Concat( _
                dirName, "\Test", i.ToString(), ".dat")

            ' Create random data to write to the file.
            byteArray = New Byte(1000000){}
            randomGenerator.NextBytes(byteArray)

            manualEvents(i) = New ManualResetEvent(false)

            stateInfo = _ 
                New State(fileName, byteArray, manualEvents(i))

            ThreadPool.QueueUserWorkItem(AddressOf _
                Writer.WriteToFile, stateInfo)
        Next i
    
        ' Since ThreadPool threads are background threads, 
        ' wait for the work items to signal before exiting.
        WaitHandle.WaitAll(manualEvents)
        Console.WriteLine("Files written - main exiting.")
    End Sub

End Class
 
' Maintain state to pass to WriteToFile.
Public Class State

    Public fileName As String
    Public byteArray As Byte()
    Public manualEvent As ManualResetEvent

    Sub New(fileName As String, byteArray() As Byte, _
        manualEvent As ManualResetEvent)
    
        Me.fileName = fileName
        Me.byteArray = byteArray
        Me.manualEvent = manualEvent
    End Sub

End Class

Public Class Writer

    Private Sub New()
    End Sub

    Shared workItemCount As Integer = 0

    Shared Sub WriteToFile(state As Object)
        Dim workItemNumber As Integer = workItemCount
        Interlocked.Increment(workItemCount)
        Console.WriteLine("Starting work item {0}.", _
            workItemNumber.ToString())
        Dim stateInfo As State = CType(state, State)
        Dim fileWriter As FileStream = Nothing

        ' Create and write to the file.
        Try
            fileWriter = New FileStream( _
                stateInfo.fileName, FileMode.Create)
            fileWriter.Write(stateInfo.byteArray, _
                0, stateInfo.byteArray.Length)
        Finally
            If Not fileWriter Is Nothing Then
                fileWriter.Close()
            End If

            ' Signal Main that the work item has finished.
            Console.WriteLine("Ending work item {0}.", _
                workItemNumber.ToString())
            stateInfo.manualEvent.Set()
        End Try
    End Sub

End Class

Açıklamalar

AbandonedMutexException .NET Framework sürüm 2.0'da yenidir. Önceki sürümlerde yöntem, WaitAll bir mutex bırakıldığında döndürür true . Terk edilmiş bir mutex genellikle ciddi bir kodlama hatasına işaret eder. Sistem genelinde bir mutex söz konusu olduğunda, bir uygulamanın aniden sonlandırıldığını gösterebilir (örneğin, Windows Görev Yöneticisi kullanılarak). Özel durum, hata ayıklama için yararlı bilgiler içerir.

Yöntemi, WaitAll tüm tanıtıcılara sinyal gönderildiğinde döndürür. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizi yinelenenler içeriyorsa, çağrısı ile DuplicateWaitObjectExceptionbaşarısız olur.

Not

yöntemi WaitAll , durumundaki iş parçacıklarında STA desteklenmez.

Bu yöntem aşırı yüklemesinin çağrılması yöntemi aşırı yüklemesinin WaitAll(WaitHandle[], Int32, Boolean) çağrılmasıyla ve için millisecondsTimeouttrue -1 (veya Timeout.Infinite) belirtilmesiyle exitContexteşdeğerdir.

Şunlara uygulanır

Aracılığıyla paylaş

WaitHandle.WaitAll Yöntem

Tanım

Aşırı Yüklemeler

WaitAll(WaitHandle[], TimeSpan, Boolean)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Bağlamdan çıkma

Şunlara uygulanır

WaitAll(WaitHandle[], Int32, Boolean)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Bağlamdan çıkma

Şunlara uygulanır

WaitAll(WaitHandle[], TimeSpan)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Şunlara uygulanır

WaitAll(WaitHandle[], Int32)

Parametreler

Döndürülenler

Özel durumlar

Açıklamalar

Şunlara uygulanır

WaitAll(WaitHandle[])

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Şunlara uygulanır

Ek kaynaklar