WaitHandle.WaitAll Yöntem

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.dll

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

Aşırı Yüklemeler

Name	Description
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ılı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ılı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

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ılı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 parametresi null'dir.

-veya-

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

-veya-

waitHandles öğesi 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ı, sistem tarafından izin verildiğinden fazladır.

-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 öğesi olmayan bir dizidir ve .NET Framework sürümü 1.0 veya 1.1'dir.

ArgumentOutOfRangeException

timeout -1 milisaniye dışında bir negatif sayıdır ve bu da sonsuz zaman aşımını temsil eder.

-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ğinde, iş parçacığı havuzunu kullanarak zaman uyumsuz olarak nasıl oluşturulacağı ve bir dosya grubuna nasıl yazacağı gösterilmektedir. Her yazma işlemi bir iş öğesi olarak kuyruğa alınır ve tamamlandığında sinyal gönderir. Ana iş parçacığı tüm öğelerin sinyal göndermesini bekler ve sonra çıkar.

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 sona erdiğinde döndürür; bu da tüm tanıtıcıların işaretlendiği veya zaman aşımı oluştuğu anlamına gelir. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizi yinelenenleri içeriyorsa, çağrı başarısız olur.

Note

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

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

Bağlamdan çıkma

Bu exitContext yöntem, bilinmeyen bir yönetilen bağlamın içinden çağrılmadığı sürece parametresinin hiçbir etkisi yoktur. İş 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ğlam uyumsuz olabilir. şu anda gibi öğesinden ContextBoundObjectStringtüretilmemiş 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, uyumsuz bir bağlamda olabilirsiniz.

Kodunuz bilinmeyen bir bağlamda yürütülürken, öğesinin exitContext belirtilmesitrue, bu yöntemi yürütmeden önce iş parçacığının bilinmeyen yönetilen bağlamdan (yani varsayılan bağlama geçiş için) çıkmasına neden olur. İş parçacığı, bu yönteme yapılan çağrı 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 için exitContextbelirtirsetrue, iş parçacığı eşitleme etki alanından çıkar ve 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ığı eşitleme etki alanını yeniden eklemek için beklemelidir.

WaitAll(WaitHandle[], Int32, Boolean)

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 birden çok başvuru içeremez (yinelemeler).

millisecondsTimeout

Int32

Beklenen milisaniye sayısı veya Infinite (-1) süresiz olarak beklemek için.

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 parametresi null'dir.

-veya-

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

-veya-

waitHandles öğesi 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ı, sistem tarafından izin verildiğinden fazladır.

-veya-

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

ApplicationException

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

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında bir negatif sayıdır ve bu da sonsuz zaman aşımını temsil eder.

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

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

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.

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 sona erdiğinde döndürür; yani tüm tanıtıcılar sinyal verildiğinde veya zaman aşımı oluştuğ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.

Note

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

Bağlamdan çıkma

Bu exitContext yöntem, bilinmeyen bir yönetilen bağlamın içinden çağrılmadığı sürece parametresinin hiçbir etkisi yoktur. İş 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ğlam uyumsuz olabilir. şu anda gibi öğesinden ContextBoundObjectStringtüretilmemiş 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, uyumsuz bir bağlamda olabilirsiniz.

Kodunuz bilinmeyen bir bağlamda yürütülürken, öğesinin exitContext belirtilmesitrue, bu yöntemi yürütmeden önce iş parçacığının bilinmeyen yönetilen bağlamdan (yani varsayılan bağlama geçiş için) çıkmasına neden olur. İş parçacığı, bu yönteme yapılan çağrı 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 için exitContextbelirtirsetrue, iş parçacığı eşitleme etki alanından çıkar ve 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ığı eşitleme etki alanını yeniden eklemek için beklemelidir.

WaitAll(WaitHandle[], TimeSpan)

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 parametresi null'dir.

-veya-

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

-veya-

waitHandles öğesi olmayan bir dizidir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

NotSupportedException

içindeki waitHandles nesne sayısı, sistem tarafından izin verildiğinden fazladır.

-veya-

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

ArgumentOutOfRangeException

timeout -1 milisaniye dışında bir negatif sayıdır ve bu da sonsuz zaman aşımını temsil eder.

-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 sona erdiğinde döndürür; bu da tüm tanıtıcıların işaretlendiği veya zaman aşımı oluştuğu anlamına gelir. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizi yinelenenleri içeriyorsa, çağrı başarısız olur.

Note

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.

WaitAll(WaitHandle[], Int32)

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 beklemek için.

Döndürülenler

Boolean

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

Özel durumlar

ArgumentNullException

waitHandles parametresi null'dir.

-veya-

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

-veya-

waitHandles öğesi olmayan bir dizidir.

DuplicateWaitObjectException

Dizi waitHandles yinelenen öğeler içerir.

NotSupportedException

içindeki waitHandles nesne sayısı, sistem tarafından izin verildiğinden fazladır.

-veya-

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

ArgumentOutOfRangeException

millisecondsTimeout , -1 dışında bir negatif sayıdır ve bu da sonsuz zaman aşımını temsil eder.

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.

WaitAll yöntemi, bekleme sona erdiğinde döndürür; yani tüm tanıtıcılar sinyal verildiğinde veya zaman aşımı oluştuğ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.

Note

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.

WaitAll(WaitHandle[])

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 parametresi null'dir. -veya-

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

-veya-

waitHandles öğesi 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ı, sistem tarafından izin verildiğinden fazladır.

-veya-

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

ApplicationException

waitHandles öğesi 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 nasıl oluşturulacağı ve bir dosya grubuna nasıl yazacağı gösterilmektedir. Her yazma işlemi bir iş öğesi olarak kuyruğa alınır ve tamamlandığında sinyal gönderir. Ana iş parçacığı tüm öğelerin sinyal göndermesini bekler ve sonra çıkar.

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ılar işaretlendiğinde döndürür. 64'ten fazla tanıtıcı geçirilirse, bir NotSupportedException oluşturulur. Dizi yinelenenleri içeriyorsa, çağrısı ile DuplicateWaitObjectExceptionbaşarısız olur.

Note

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

Bu yöntem aşırı yüklemesinin çağrılması, yöntem aşırı yüklemesini WaitAll(WaitHandle[], Int32, Boolean) çağırmaya ve ve için millisecondsTimeouttrueexitContext-1 (veya Timeout.Infinite) belirtmeye eşdeğerdir.