Bagikan melalui

MessageQueue.BeginReceive Metode

  • Referensi

Definisi

Ruang nama:
System.Messaging
Rakitan:
System.Messaging.dll

Memulai operasi penerimaan asinkron dengan memberi tahu Message Queuing untuk mulai menerima pesan dan memberi tahu penanganan aktivitas setelah selesai.

Overload

BeginReceive()

Memulai operasi penerimaan asinkron yang tidak memiliki waktu habis. Operasi tidak selesai sampai pesan tersedia dalam antrean.
BeginReceive(TimeSpan)

Memulai operasi penerimaan asinkron yang memiliki waktu habis yang ditentukan. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.
BeginReceive(TimeSpan, Object)

Memulai operasi penerimaan asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.
BeginReceive(TimeSpan, Object, AsyncCallback)

Memulai operasi penerimaan asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Memulai operasi penerimaan asinkron yang memiliki batas waktu tertentu dan menggunakan kursor tertentu dan objek status tertentu. Objek status menyediakan informasi terkait sepanjang masa operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

BeginReceive()

Memulai operasi penerimaan asinkron yang tidak memiliki waktu habis. Operasi tidak selesai sampai pesan tersedia dalam antrean.

public:
 IAsyncResult ^ BeginReceive();
public IAsyncResult BeginReceive ();
member this.BeginReceive : unit -> IAsyncResult
Public Function BeginReceive () As IAsyncResult

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut menautkan permintaan asinkron. Ini mengasumsikan ada antrean di komputer lokal yang disebut "myQueue". Fungsi ini Main memulai operasi asinkron yang ditangani oleh MyReceiveCompleted rutinitas. MyReceiveCompleted memproses pesan saat ini dan memulai operasi penerimaan asinkron baru.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Define static class members.
   static ManualResetEvent^ signal = gcnew ManualResetEvent( false );
   static int count = 0;

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );
         count += 1;
         if ( count == 10 )
         {
            signal->Set();
         }

         // Restart the asynchronous receive operation.
         mq->BeginReceive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }

      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Begin the asynchronous receive operation.
   myQueue->BeginReceive();
   MyNewQueue::signal->WaitOne();

   // Do other work on the current thread.
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {
        // Define static class members.
        static ManualResetEvent signal = new ManualResetEvent(false);
        static int count = 0;

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Begin the asynchronous receive operation.
            myQueue.BeginReceive();

            signal.WaitOne();
            
            // Do other work on the current thread.

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
                
                count += 1;
                if (count == 10)
                {
                    signal.Set();
                }

                // Restart the asynchronous receive operation.
                mq.BeginReceive();
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading




' Provides a container class for the example.

Public Class MyNewQueue

        ' Define static class members.
        Private Shared signal As New ManualResetEvent(False)
        Private Shared count As Integer = 0



        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()
            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Begin the asynchronous receive operation.
            myQueue.BeginReceive()

            signal.WaitOne()

            ' Do other work on the current thread.

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                count += 1
                If count = 10 Then
                    signal.Set()
                End If

                ' Restart the asynchronous receive operation.
                mq.BeginReceive()

            Catch
                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Contoh kode berikut mengantrekan permintaan asinkron. Panggilan untuk BeginReceive menggunakan dalam nilai pengembaliannya AsyncWaitHandle . Rutinitas Main menunggu semua operasi asinkron selesai sebelum keluar.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Threading;

ref class MyNewQueue
{
public:

   // Provides an event handler for the ReceiveCompleted
   // event.
   static void MyReceiveCompleted( Object^ source, ReceiveCompletedEventArgs^ asyncResult )
   {
      try
      {
         // Connect to the queue.
         MessageQueue^ mq = dynamic_cast<MessageQueue^>(source);

         // End the asynchronous receive operation.
         mq->EndReceive( asyncResult->AsyncResult );

         // Process the message here.
         Console::WriteLine( "Message received." );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of MessageQueueException.
      }
      // Handle other exceptions.
      return;
   }
};

// Provides an entry point into the application.
//         
// This example performs asynchronous receive
// operation processing.
int main()
{
   // Create an instance of MessageQueue. Set its formatter.
   MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
   array<Type^>^p = gcnew array<Type^>(1);
   p[ 0 ] = String::typeid;
   myQueue->Formatter = gcnew XmlMessageFormatter( p );

   // Add an event handler for the ReceiveCompleted event.
   myQueue->ReceiveCompleted += gcnew ReceiveCompletedEventHandler( MyNewQueue::MyReceiveCompleted );

   // Define wait handles for multiple operations.
   array<WaitHandle^>^waitHandleArray = gcnew array<WaitHandle^>(10);
   for ( int i = 0; i < 10; i++ )
   {
      // Begin asynchronous operations.
      waitHandleArray[ i ] = myQueue->BeginReceive()->AsyncWaitHandle;
   }

   // Specify to wait for all operations to return.
   WaitHandle::WaitAll( waitHandleArray );
   return 0;
}

using System;
using System.Messaging;
using System.Threading;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example performs asynchronous receive
        // operation processing.
        //**************************************************

        public static void Main()
        {
            // Create an instance of MessageQueue. Set its formatter.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});

            // Add an event handler for the ReceiveCompleted event.
            myQueue.ReceiveCompleted +=
                new ReceiveCompletedEventHandler(MyReceiveCompleted);
            
            // Define wait handles for multiple operations.
            WaitHandle[] waitHandleArray = new WaitHandle[10];
            for(int i=0; i<10; i++)
            {
                // Begin asynchronous operations.
                waitHandleArray[i] =
                    myQueue.BeginReceive().AsyncWaitHandle;
            }

            // Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray);

            return;
        }

        //***************************************************
        // Provides an event handler for the ReceiveCompleted
        // event.
        //***************************************************
        
        private static void MyReceiveCompleted(Object source,
            ReceiveCompletedEventArgs asyncResult)
        {
            try
            {
                // Connect to the queue.
                MessageQueue mq = (MessageQueue)source;

                // End the asynchronous receive operation.
                Message m = mq.EndReceive(asyncResult.AsyncResult);
        
                // Process the message here.
                Console.WriteLine("Message received.");
            }
            catch(MessageQueueException)
            {
                // Handle sources of MessageQueueException.
            }
            
            // Handle other exceptions.
            
            return;
        }
    }
}

Imports System.Messaging
Imports System.Threading


' Provides a container class for the example.

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example performs asynchronous receive
        ' operation processing.


        Public Shared Sub Main()

            ' Create an instance of MessageQueue. Set its formatter.
            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Add an event handler for the ReceiveCompleted event.
            AddHandler myQueue.ReceiveCompleted, AddressOf _
                MyReceiveCompleted

            ' Define wait handles for multiple operations.
            Dim waitHandleArray(10) As WaitHandle

            Dim i As Integer
            For i = 0 To 9
                ' Begin asynchronous operations.
                waitHandleArray(i) = _
                    myQueue.BeginReceive().AsyncWaitHandle
            Next i

            ' Specify to wait for all operations to return.
            WaitHandle.WaitAll(waitHandleArray)

            Return

        End Sub



        ' Provides an event handler for the ReceiveCompleted
        ' event.


        Private Shared Sub MyReceiveCompleted(ByVal [source] As _
            [Object], ByVal asyncResult As ReceiveCompletedEventArgs)

            Try
                ' Connect to the queue.
                Dim mq As MessageQueue = CType([source], MessageQueue)

                ' End the asynchronous receive operation.
                Dim m As Message = _
                    mq.EndReceive(asyncResult.AsyncResult)

                ' Process the message here.
                Console.WriteLine("Message received.")

            Catch

                ' Handle sources of MessageQueueException.

                ' Handle other exceptions.

            End Try

            Return

        End Sub

End Class

Keterangan

Dalam pemrosesan asinkron, Anda menggunakan BeginReceive untuk menaikkan ReceiveCompleted peristiwa ketika pesan telah dihapus dari antrean.

ReceiveCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Untuk menggunakan BeginReceive, buat penanganan aktivitas yang memproses hasil operasi asinkron dan kaitkan dengan delegasi peristiwa Anda. BeginReceive memulai operasi penerimaan asinkron; MessageQueue diberi tahu, melalui peningkatan ReceiveCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndReceive(IAsyncResult).

Metode BeginReceive segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginReceive asinkron, Anda dapat memanggilnya untuk menerima pesan dari antrean tanpa memblokir utas eksekusi saat ini. Untuk menerima pesan secara sinkron, gunakan metode .Receive

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

IAsyncResult yang BeginReceive mengembalikan mengidentifikasi operasi asinkron yang dimulai metode. Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndReceive(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti untuk IAsyncResult mengidentifikasi operasi yang telah selesai.

Jika CanRead adalah false, peristiwa penyelesaian dinaikkan, tetapi pengecualian akan dilemparkan saat memanggil EndReceive(IAsyncResult).

Jangan gunakan panggilan BeginReceive asinkron dengan transaksi. Jika Anda ingin melakukan operasi asinkron transaksional, panggil BeginPeek, dan letakkan transaksi dan metode (sinkron) Receive dalam penanganan aktivitas yang Anda buat untuk operasi intip. Penanganan aktivitas Anda mungkin berisi fungsionalitas seperti yang ditunjukkan dalam kode C# berikut.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

BeginReceive(TimeSpan)

Memulai operasi penerimaan asinkron yang memiliki waktu habis yang ditentukan. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout);
public IAsyncResult BeginReceive (TimeSpan timeout);
member this.BeginReceive : TimeSpan -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan) As IAsyncResult

Parameter

timeout
TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid, mungkin karena mewakili angka negatif.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat operasi penerimaan asinkron. Contoh kode membuat penanganan aktivitas, MyReceiveCompleted, dan melampirkannya ke ReceiveCompleted delegasi penanganan aktivitas. Contoh kode mengirim pesan ke antrean pesan lokal, lalu memanggil BeginReceive(TimeSpan), meneruskan nilai waktu habis sepuluh detik. ReceiveCompleted Saat peristiwa dinaikkan, penanganan aktivitas menerima pesan dan menulis isi pesan ke layar.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message body: {0}", msg->Body);
    
    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }

    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }

}


using System;
using System.Messaging;

public class QueueExample
{
    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
                ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0));

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Keterangan

Dalam pemrosesan asinkron, Anda menggunakan BeginReceive untuk menaikkan ReceiveCompleted peristiwa saat pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa.

ReceiveCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Untuk menggunakan BeginReceive, buat penanganan aktivitas yang memproses hasil operasi asinkron dan kaitkan dengan delegasi peristiwa Anda. BeginReceive memulai operasi penerimaan asinkron; MessageQueue diberi tahu, melalui peningkatan ReceiveCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndReceive(IAsyncResult) atau mengambil hasilnya menggunakan ReceiveCompletedEventArgs.

Metode BeginReceive segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginReceive asinkron, Anda dapat memanggilnya untuk menerima pesan dari antrean tanpa memblokir utas eksekusi saat ini. Untuk menerima pesan secara sinkron, gunakan metode .Receive

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

Jika CanRead adalah false, peristiwa penyelesaian dinaikkan, tetapi pengecualian akan dilemparkan saat memanggil EndReceive(IAsyncResult).

IAsyncResult yang BeginReceive mengembalikan mengidentifikasi operasi asinkron yang dimulai metode. Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndReceive(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti untuk IAsyncResult mengidentifikasi operasi yang telah selesai.

Kelebihan beban ini menentukan waktu habis. Jika interval yang ditentukan oleh parameter kedaluwarsa timeout , komponen ini akan menaikkan ReceiveCompleted peristiwa. Karena tidak ada pesan, panggilan berikutnya ke EndReceive(IAsyncResult) akan melemparkan pengecualian.

Jangan gunakan panggilan BeginReceive asinkron dengan transaksi. Jika Anda ingin melakukan operasi asinkron transaksional, panggil BeginPeek, dan letakkan transaksi dan metode (sinkron) Receive dalam penanganan aktivitas yang Anda buat untuk operasi intip. Penanganan aktivitas Anda mungkin berisi fungsionalitas seperti yang ditunjukkan dalam kode C# berikut.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

BeginReceive(TimeSpan, Object)

Memulai operasi penerimaan asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject);
public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject);
member this.BeginReceive : TimeSpan * obj -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, stateObject As Object) As IAsyncResult

Parameter

timeout
TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

stateObject
Object

Objek status, yang ditentukan oleh aplikasi, yang berisi informasi yang terkait dengan operasi asinkron.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat operasi penerimaan asinkron. Contoh kode membuat penanganan aktivitas, MyReceiveCompleted, dan melampirkannya ke ReceiveCompleted delegasi penanganan aktivitas. Contoh kode mengirim pesan ke antrean pesan lokal, lalu memanggil BeginReceive(TimeSpan, Object), meneruskan nilai waktu habis sepuluh detik dan bilangan bulat unik yang mengidentifikasi pesan tertentu tersebut. ReceiveCompleted Saat peristiwa dinaikkan, penanganan aktivitas menerima pesan dan menulis isi pesan dan pengidentifikasi pesan bilangan bulat ke layar.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if(!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(Object^ source, ReceiveCompletedEventArgs^ e)
{
    // Connect to the queue.
    MessageQueue^ queue = (MessageQueue^)source;

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(e->AsyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", e->AsyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;

    // Represents a state object associated with each message.
    int messageNumber = 0;

    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue->ReceiveCompleted += gcnew
            ReceiveCompletedEventHandler(HandleReceiveCompleted);

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Add an event handler for the ReceiveCompleted event.
        queue.ReceiveCompleted += new
            ReceiveCompletedEventHandler(MyReceiveCompleted);

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++);

        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(Object source,
        ReceiveCompletedEventArgs asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = (MessageQueue)source;

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult.AsyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}",
            (int)asyncResult.AsyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Keterangan

Dalam pemrosesan asinkron, Anda menggunakan BeginReceive untuk menaikkan ReceiveCompleted peristiwa saat pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa.

ReceiveCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Gunakan kelebihan beban ini untuk mengaitkan informasi dengan operasi yang akan dipertahankan selama masa pakai operasi. Penanganan aktivitas dapat mendeteksi informasi ini dengan melihat AsyncState properti IAsyncResult yang terkait dengan operasi.

Untuk menggunakan BeginReceive, buat penanganan aktivitas yang memproses hasil operasi asinkron dan kaitkan dengan delegasi peristiwa Anda. BeginReceive memulai operasi penerimaan asinkron; MessageQueue diberi tahu, melalui peningkatan ReceiveCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndReceive(IAsyncResult) atau mengambil hasilnya menggunakan ReceiveCompletedEventArgs.

Metode BeginReceive segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginReceive asinkron, Anda dapat memanggilnya untuk menerima pesan dari antrean tanpa memblokir utas eksekusi saat ini. Untuk menerima pesan secara sinkron, gunakan metode .Receive

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

IAsyncResult yang BeginReceive mengembalikan mengidentifikasi operasi asinkron yang dimulai metode. Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndReceive(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti untuk IAsyncResult mengidentifikasi operasi yang telah selesai.

Kelebihan beban ini menentukan waktu habis dan objek status. Jika interval yang ditentukan oleh parameter kedaluwarsa timeout , komponen ini akan menaikkan ReceiveCompleted peristiwa. Karena tidak ada pesan, panggilan berikutnya ke EndReceive(IAsyncResult) akan melemparkan pengecualian.

Objek status mengaitkan informasi status dengan operasi. Misalnya, jika Anda memanggil BeginReceive beberapa kali untuk memulai beberapa operasi, Anda dapat mengidentifikasi setiap operasi melalui objek status terpisah yang Anda tentukan.

Anda juga dapat menggunakan objek status untuk meneruskan informasi di seluruh utas proses. Jika utas dimulai tetapi panggilan balik berada di utas yang berbeda dalam skenario asinkron, objek status di-marshalasikan dan diteruskan kembali bersama dengan informasi dari peristiwa tersebut.

Jangan gunakan panggilan BeginReceive asinkron dengan transaksi. Jika Anda ingin melakukan operasi asinkron transaksional, panggil BeginPeek, dan letakkan transaksi dan metode (sinkron) Receive dalam penanganan aktivitas yang Anda buat untuk operasi intip. Penanganan aktivitas Anda mungkin berisi fungsionalitas seperti yang ditunjukkan dalam kode C# berikut.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

BeginReceive(TimeSpan, Object, AsyncCallback)

Memulai operasi penerimaan asinkron yang memiliki batas waktu tertentu dan objek status tertentu, yang menyediakan informasi terkait sepanjang masa pakai operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Object ^ stateObject, AsyncCallback ^ callback);
public IAsyncResult BeginReceive (TimeSpan timeout, object stateObject, AsyncCallback callback);
member this.BeginReceive : TimeSpan * obj * AsyncCallback -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, stateObject As Object, callback As AsyncCallback) As IAsyncResult

Parameter

timeout
TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

stateObject
Object

Objek status, yang ditentukan oleh aplikasi, yang berisi informasi yang terkait dengan operasi asinkron.

callback
AsyncCallback

AsyncCallback yang akan menerima pemberitahuan penyelesaian operasi asinkron.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Contoh

Contoh kode berikut membuat operasi penerimaan asinkron. Contoh kode mengirim pesan ke antrean pesan lokal, lalu memanggil BeginReceive(TimeSpan, Object, AsyncCallback), meneruskan: nilai waktu habis sepuluh detik; bilangan bulat unik yang mengidentifikasi pesan tertentu; dan instans AsyncCallback baru yang mengidentifikasi penanganan aktivitas, MyReceiveCompleted. ReceiveCompleted Saat peristiwa dinaikkan, penanganan aktivitas menerima pesan dan menulis isi pesan dan pengidentifikasi pesan bilangan bulat ke layar.

#using <System.Messaging.dll>
#using <System.dll>

using namespace System;
using namespace System::Messaging;

// Creates a new queue.
void CreateQueue(String^ queuePath, bool transactional)
{
    if (!MessageQueue::Exists(queuePath))
    {
        MessageQueue^ queue = MessageQueue::Create(queuePath, transactional);
        queue->Close();       
    }
    else
    {
        Console::WriteLine("{0} already exists.", queuePath);
    }
}

// Provides an event handler for the ReceiveCompleted event.
void HandleReceiveCompleted(IAsyncResult^ asyncResult)
{
    // Connect to the queue.
    MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue");

    // End the asynchronous receive operation.
    Message^ msg = queue->EndReceive(asyncResult);

    // Display the message information on the screen.
    Console::WriteLine("Message number: {0}", asyncResult->AsyncState);
    Console::WriteLine("Message body: {0}", msg->Body);

    queue->Close();
}

int main()
{
    // Represents a state object associated with each message.
    int messageNumber = 0;

    // Create a non-transactional queue on the local computer.
    // Note that the queue might not be immediately accessible, and
    // therefore this example might throw an exception of type
    // System.Messaging.MessageQueueException when trying to send a
    // message to the newly created queue.
    MessageQueue^ queue = nullptr;
    try
    {
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        queue = gcnew MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue->Send("Example Message");

        // Begin the asynchronous receive operation.
        queue->BeginReceive(TimeSpan::FromSeconds(10.0), messageNumber++,
            gcnew AsyncCallback(HandleReceiveCompleted));

        // Simulate doing other work on the current thread.
        System::Threading::Thread::Sleep(TimeSpan::FromSeconds(10.0));
    }
    catch (InvalidOperationException^)
    {
        Console::WriteLine("Please install Message Queuing.");
    }

    catch (MessageQueueException^ ex)
    {
        Console::WriteLine(ex->Message);
    }

    finally
    {   
        queue->Close();
    }
}


using System;
using System.Messaging;

public class QueueExample
{
    // Represents a state object associated with each message.
    static int messageNumber = 0;

    public static void Main()
    {
        // Create a non-transactional queue on the local computer.
        // Note that the queue might not be immediately accessible, and
        // therefore this example might throw an exception of type
        // System.Messaging.MessageQueueException when trying to send a
        // message to the newly created queue.
        CreateQueue(".\\exampleQueue", false);

        // Connect to a queue on the local computer.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // Send a message to the queue.
        queue.Send("Example Message");

        // Begin the asynchronous receive operation.
        queue.BeginReceive(TimeSpan.FromSeconds(10.0), messageNumber++,
            new AsyncCallback(MyReceiveCompleted));
            
        // Simulate doing other work on the current thread.
        System.Threading.Thread.Sleep(TimeSpan.FromSeconds(10.0));

        return;
    }

    // Creates a new queue.
    public static void CreateQueue(string queuePath, bool transactional)
    {
        if(!MessageQueue.Exists(queuePath))
        {
            MessageQueue.Create(queuePath, transactional);
        }
        else
        {
            Console.WriteLine(queuePath + " already exists.");
        }
    }

    // Provides an event handler for the ReceiveCompleted event.
    private static void MyReceiveCompleted(IAsyncResult asyncResult)
    {
        // Connect to the queue.
        MessageQueue queue = new MessageQueue(".\\exampleQueue");

        // End the asynchronous receive operation.
        Message msg = queue.EndReceive(asyncResult);

        // Display the message information on the screen.
        Console.WriteLine("Message number: {0}", (int)asyncResult.AsyncState);
        Console.WriteLine("Message body: {0}", (string)msg.Body);
    }
}

Keterangan

Ketika Anda menggunakan kelebihan beban ini, panggilan balik yang ditentukan dalam parameter panggilan balik dipanggil secara langsung ketika pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa; ReceiveCompleted peristiwa tidak dinaikkan. Kelebihan beban lainnya mengandalkan BeginReceive komponen ini untuk menaikkan ReceiveCompleted peristiwa.

ReceiveCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Untuk menggunakan BeginReceive, buat penanganan aktivitas yang memproses hasil operasi asinkron dan kaitkan dengan delegasi peristiwa Anda. BeginReceive memulai operasi penerimaan asinkron; MessageQueue diberi tahu, melalui peningkatan ReceiveCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndReceive(IAsyncResult) atau mengambil hasilnya menggunakan ReceiveCompletedEventArgs.

Metode BeginReceive segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginReceive asinkron, Anda dapat memanggilnya untuk menerima pesan dari antrean tanpa memblokir utas eksekusi saat ini. Untuk menerima pesan secara sinkron, gunakan metode .Receive

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

IAsyncResult yang BeginReceive mengembalikan mengidentifikasi operasi asinkron yang dimulai metode. Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndReceive(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, Anda menggunakan AsyncWaitHandle properti untuk IAsyncResult mengidentifikasi operasi yang telah selesai.

Objek status mengaitkan informasi status dengan operasi. Misalnya, jika Anda memanggil BeginReceive beberapa kali untuk memulai beberapa operasi, Anda dapat mengidentifikasi setiap operasi melalui objek status terpisah yang Anda tentukan.

Anda juga dapat menggunakan objek status untuk meneruskan informasi di seluruh utas proses. Jika utas dimulai tetapi panggilan balik berada di utas yang berbeda dalam skenario asinkron, objek status di-marshalasikan dan diteruskan kembali bersama dengan informasi dari peristiwa tersebut.

Jangan gunakan panggilan BeginReceive asinkron dengan transaksi. Jika Anda ingin melakukan operasi asinkron transaksional, panggil BeginPeek, dan letakkan transaksi dan metode (sinkron) Receive dalam penanganan aktivitas yang Anda buat untuk operasi intip. Penanganan aktivitas Anda mungkin berisi fungsionalitas seperti yang ditunjukkan dalam kode C# berikut.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Tabel berikut menunjukkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

Memulai operasi penerimaan asinkron yang memiliki batas waktu tertentu dan menggunakan kursor tertentu dan objek status tertentu. Objek status menyediakan informasi terkait sepanjang masa operasi. Kelebihan beban ini menerima pemberitahuan, melalui panggilan balik, identitas penanganan aktivitas untuk operasi. Operasi tidak selesai sampai pesan tersedia dalam antrean atau waktu habis terjadi.

public:
 IAsyncResult ^ BeginReceive(TimeSpan timeout, System::Messaging::Cursor ^ cursor, System::Object ^ state, AsyncCallback ^ callback);
public IAsyncResult BeginReceive (TimeSpan timeout, System.Messaging.Cursor cursor, object state, AsyncCallback callback);
member this.BeginReceive : TimeSpan * System.Messaging.Cursor * obj * AsyncCallback -> IAsyncResult
Public Function BeginReceive (timeout As TimeSpan, cursor As Cursor, state As Object, callback As AsyncCallback) As IAsyncResult

Parameter

timeout
TimeSpan

TimeSpan yang menunjukkan interval waktu untuk menunggu pesan tersedia.

cursor
Cursor

Cursor yang mempertahankan posisi tertentu dalam antrean pesan.

state
Object

Objek status, yang ditentukan oleh aplikasi, yang berisi informasi yang terkait dengan operasi asinkron.

callback
AsyncCallback

AsyncCallback yang menerima pemberitahuan penyelesaian operasi asinkron.

Mengembalikan

IAsyncResult

IAsyncResult yang mengidentifikasi permintaan asinkron yang diposting.

Pengecualian

ArgumentNullException

Parameternya cursor adalah null.

ArgumentException

Nilai yang ditentukan untuk timeout parameter tidak valid.

MessageQueueException

Terjadi kesalahan saat mengakses metode Antrean Pesan.

Keterangan

Ketika Anda menggunakan kelebihan beban ini, panggilan balik yang ditentukan dalam parameter panggilan balik dipanggil secara langsung ketika pesan tersedia dalam antrean atau ketika interval waktu yang ditentukan telah kedaluwarsa; ReceiveCompleted peristiwa tidak dinaikkan. Kelebihan beban lain mengandalkan BeginReceive komponen ini untuk meningkatkan ReceiveCompleted peristiwa.

ReceiveCompleted juga dinaikkan jika pesan sudah ada dalam antrean.

Untuk menggunakan BeginReceive, buat penanganan aktivitas yang memproses hasil operasi asinkron dan mengaitkannya dengan delegasi peristiwa Anda. BeginReceive memulai operasi penerimaan asinkron; MessageQueue diberi tahu, melalui penggalangan ReceiveCompleted peristiwa, ketika pesan tiba dalam antrean. MessageQueue kemudian dapat mengakses pesan dengan memanggil EndReceive(IAsyncResult) atau mengambil hasilnya menggunakan ReceiveCompletedEventArgs.

Metode BeginReceive ini segera kembali, tetapi operasi asinkron tidak selesai sampai penanganan aktivitas dipanggil.

Karena BeginReceive asinkron, Anda dapat memanggilnya untuk menerima pesan dari antrean tanpa memblokir utas eksekusi saat ini. Untuk menerima pesan secara sinkron, gunakan metode .Receive

Setelah operasi asinkron selesai, Anda dapat memanggil BeginPeek atau BeginReceive lagi di penanganan aktivitas untuk terus menerima pemberitahuan.

IAsyncResult yang BeginReceive mengembalikan mengidentifikasi operasi asinkron yang dimulai oleh metode . Anda dapat menggunakan ini IAsyncResult sepanjang masa operasi, meskipun Anda umumnya tidak menggunakannya sampai EndReceive(IAsyncResult) dipanggil. Namun, jika Anda memulai beberapa operasi asinkron, Anda dapat menempatkan nilainya IAsyncResult dalam array dan menentukan apakah akan menunggu semua operasi atau operasi apa pun selesai. Dalam hal ini, gunakan AsyncWaitHandle properti dari IAsyncResult untuk mengidentifikasi operasi yang telah selesai.

Objek status mengaitkan informasi status dengan operasi. Misalnya, jika Anda memanggil BeginReceive beberapa kali untuk memulai beberapa operasi, Anda dapat mengidentifikasi setiap operasi melalui objek status terpisah yang Anda tentukan.

Anda juga dapat menggunakan objek status untuk meneruskan informasi di seluruh utas proses. Jika utas dimulai tetapi panggilan balik berada di utas yang berbeda dalam skenario asinkron, objek status dinamai dan diteruskan kembali bersama dengan informasi dari peristiwa tersebut.

Jangan gunakan panggilan BeginReceive asinkron dengan transaksi. Jika Anda ingin melakukan operasi asinkron transaksional, panggil BeginPeek, dan letakkan transaksi dan metode (sinkron) Receive dalam penanganan aktivitas yang Anda buat untuk operasi intip. Penanganan aktivitas Anda mungkin berisi fungsionalitas seperti yang ditunjukkan dalam kode C# berikut.

myMessageQueue.BeginTransaction();
 myMessageQueue.Receive();
 myMessageQueue.CommitTransaction();

Tabel berikut ini memperlihatkan apakah metode ini tersedia dalam berbagai mode Grup Kerja.

Mode grup kerja Tersedia
Komputer lokal Ya
Komputer lokal dan nama format langsung Ya
Komputer jarak jauh Tidak
Komputer jarak jauh dan nama format langsung Ya

Lihat juga

Berlaku untuk

Keamanan Thread

Metode ini tidak aman untuk utas.