MessageQueue Sınıf

Tanım

Ad Alanı:

System.Messaging

Bütünleştirilmiş Kod:

System.Messaging.dll

Message Queuing sunucusundaki kuyruğa erişim sağlar.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable

[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

Public Class MessageQueue
Inherits Component
Implements IEnumerable

Devralma

Object

MarshalByRefObject

Component

MessageQueue

Öznitelikler

TypeConverterAttribute MessagingDescriptionAttribute

Uygulamalar

IEnumerable

Örnekler

Aşağıdaki kod örneği, çeşitli yol adı söz dizimi türlerini kullanarak yeni MessageQueue nesneler oluşturur. Her durumda, yolu oluşturucuda tanımlanan kuyruğa bir ileti gönderir.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // References public queues.
   void SendPublic()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->Send( "Public queue by path name." );
      return;
   }


   // References private queues.
   void SendPrivate()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\Private$\\myQueue" );
      myQueue->Send( "Private queue by path name." );
      return;
   }


   // References queues by label.
   void SendByLabel()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "Label:TheLabel" );
      myQueue->Send( "Queue by label." );
      return;
   }


   // References queues by format name.
   void SendByFormatName()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "FormatName:Public=5A5F7535-AE9A-41d4 -935C-845C2AFF7112" );
      myQueue->Send( "Queue by format name." );
      return;
   }


   // References computer journal queues.
   void MonitorComputerJournal()
   {
      MessageQueue^ computerJournal = gcnew MessageQueue( ".\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = computerJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References queue journal queues.
   void MonitorQueueJournal()
   {
      MessageQueue^ queueJournal = gcnew MessageQueue( ".\\myQueue\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = queueJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References dead-letter queues.
   void MonitorDeadLetter()
   {
      MessageQueue^ deadLetter = gcnew MessageQueue( ".\\DeadLetter$" );
      while ( true )
      {
         Message^ deadMessage = deadLetter->Receive();
         
         // Process the dead-letter message.
      }
   }


   // References transactional dead-letter queues.
   void MonitorTransactionalDeadLetter()
   {
      MessageQueue^ TxDeadLetter = gcnew MessageQueue( ".\\XactDeadLetter$" );
      while ( true )
      {
         Message^ txDeadLetter = TxDeadLetter->Receive();
         
         // Process the transactional dead-letter message.
      }
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example demonstrates several ways to set
// a queue's path.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   myNewQueue->SendPublic();
   myNewQueue->SendPrivate();
   myNewQueue->SendByLabel();
   myNewQueue->SendByFormatName();
   myNewQueue->MonitorComputerJournal();
   myNewQueue->MonitorQueueJournal();
   myNewQueue->MonitorDeadLetter();
   myNewQueue->MonitorTransactionalDeadLetter();
   return 0;
}

using System;
using System.Messaging;

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

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example demonstrates several ways to set
        // a queue's path.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            myNewQueue.SendPublic();
            myNewQueue.SendPrivate();
            myNewQueue.SendByLabel();
            myNewQueue.SendByFormatName();
            myNewQueue.MonitorComputerJournal();
            myNewQueue.MonitorQueueJournal();
            myNewQueue.MonitorDeadLetter();
            myNewQueue.MonitorTransactionalDeadLetter();

            return;
        }
        
        // References public queues.
        public void SendPublic()
        {
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Send("Public queue by path name.");

            return;
        }

        // References private queues.
        public void SendPrivate()
        {
            MessageQueue myQueue = new
                MessageQueue(".\\Private$\\myQueue");
            myQueue.Send("Private queue by path name.");

            return;
        }

        // References queues by label.
        public void SendByLabel()
        {
            MessageQueue myQueue = new MessageQueue("Label:TheLabel");
            myQueue.Send("Queue by label.");

            return;
        }

        // References queues by format name.
        public void SendByFormatName()
        {
            MessageQueue myQueue = new
                MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" +
                "-935C-845C2AFF7112");
            myQueue.Send("Queue by format name.");

            return;
        }

        // References computer journal queues.
        public void MonitorComputerJournal()
        {
            MessageQueue computerJournal = new
                MessageQueue(".\\Journal$");
            while(true)
            {
                Message journalMessage = computerJournal.Receive();
                // Process the journal message.
            }
        }

        // References queue journal queues.
        public void MonitorQueueJournal()
        {
            MessageQueue queueJournal = new
                MessageQueue(".\\myQueue\\Journal$");
            while(true)
            {
                Message journalMessage = queueJournal.Receive();
                // Process the journal message.
            }
        }
        
        // References dead-letter queues.
        public void MonitorDeadLetter()
        {
            MessageQueue deadLetter = new
                MessageQueue(".\\DeadLetter$");
            while(true)
            {
                Message deadMessage = deadLetter.Receive();
                // Process the dead-letter message.
            }
        }

        // References transactional dead-letter queues.
        public void MonitorTransactionalDeadLetter()
        {
            MessageQueue TxDeadLetter = new
                MessageQueue(".\\XactDeadLetter$");
            while(true)
            {
                Message txDeadLetter = TxDeadLetter.Receive();
                // Process the transactional dead-letter message.
            }
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example demonstrates several ways to set
        ' a queue's path.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            myNewQueue.SendPublic()
            myNewQueue.SendPrivate()
            myNewQueue.SendByLabel()
            myNewQueue.SendByFormatName()
            myNewQueue.MonitorComputerJournal()
            myNewQueue.MonitorQueueJournal()
            myNewQueue.MonitorDeadLetter()
            myNewQueue.MonitorTransactionalDeadLetter()

            Return

        End Sub


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub


        ' References queues by format name.
        Public Sub SendByFormatName()

            Dim myQueue As New _
                MessageQueue("FormatName:Public=" + _
                    "5A5F7535-AE9A-41d4-935C-845C2AFF7112")
            myQueue.Send("Queue by format name.")

            Return

        End Sub


        ' References computer journal queues.
        Public Sub MonitorComputerJournal()

            Dim computerJournal As New MessageQueue(".\Journal$")

            While True

                Dim journalMessage As Message = _
                    computerJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References queue journal queues.
        Public Sub MonitorQueueJournal()

            Dim queueJournal As New _
                            MessageQueue(".\myQueue\Journal$")

            While True

                Dim journalMessage As Message = _
                    queueJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References dead-letter queues.
        Public Sub MonitorDeadLetter()
            Dim deadLetter As New MessageQueue(".\DeadLetter$")

            While True

                Dim deadMessage As Message = deadLetter.Receive()

                ' Process the dead-letter message.

            End While

            Return

        End Sub


        ' References transactional dead-letter queues.
        Public Sub MonitorTransactionalDeadLetter()

            Dim TxDeadLetter As New MessageQueue(".\XactDeadLetter$")

            While True

                Dim txDeadLetterMessage As Message = _
                    TxDeadLetter.Receive()

                ' Process the transactional dead-letter message.

            End While

            Return

        End Sub

End Class

Aşağıdaki kod örneği kuyruğa bir ileti gönderir ve adlı Orderuygulamaya özgü bir sınıf kullanarak kuyruktan bir ileti alır.

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

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // Create a new order and set values.
      Order^ sentOrder = gcnew Order;
      sentOrder->orderId = 3;
      sentOrder->orderTime = DateTime::Now;

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

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = static_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object the following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

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

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // Create a new order and set values.
            Order sentOrder = new Order();
            sentOrder.orderId = 3;
            sentOrder.orderTime = DateTime.Now;

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

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            return;
        }

        //**************************************************
        // Receives a message containing an Order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

    ' This class represents an object the following example 
    ' sends to a queue and receives from a queue.
    Public Class Order
        Public orderId As Integer
        Public orderTime As DateTime
    End Class


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessage()

            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType(Order)})

            Try

                ' Receive and format the message. 
                Dim myMessage As Message = myQueue.Receive()
                Dim myOrder As Order = CType(myMessage.Body, Order)

                ' Display message information.
                Console.WriteLine(("Order ID: " + _
                    myOrder.orderId.ToString()))
                Console.WriteLine(("Sent: " + _
                    myOrder.orderTime.ToString()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

Açıklamalar

Message Queuing teknolojisi, farklı zamanlarda çalışan uygulamaların geçici olarak çevrimdışı olabilecek heterojen ağlar ve sistemler arasında iletişim kurmasına olanak tanır. Uygulamalar kuyruklardan ileti gönderir, alır veya kuyruğa göz atarak (kaldırmadan okur). Message Queuing, Windows 2000 ve Windows NT'nin isteğe bağlı bir bileşenidir ve ayrı olarak yüklenmesi gerekir.

sınıfı Message MessageQueue Queuing çevresindeki bir sarmalayıcıdır. Message Queuing'in birden çok sürümü vardır ve sınıfı kullanmak MessageQueue , kullandığınız işletim sistemine bağlı olarak biraz farklı davranışlara neden olabilir.

sınıfı bir MessageQueue Message Queuing kuyruğuna başvuru sağlar. Var olan bir kaynağa bağlanmak için oluşturucuda MessageQueue bir yol belirtebilir veya sunucuda yeni bir kuyruk oluşturabilirsiniz. , veya çağırabilmeniz Send(Object)için önce sınıfın yeni örneğini MessageQueue mevcut bir kuyrukla ilişkilendirmeniz Receivegerekir. Peek Bu noktada ve Labelgibi Category kuyruk özelliklerini işleyebilirsiniz.

MessageQueue iki tür ileti almayı destekler: zaman uyumlu ve zaman uyumsuz. Zaman uyumlu yöntemler ve Receive, Peek işlem iş parçacığının yeni bir iletinin kuyruğa ulaşması için belirtilen zaman aralığını beklemesine neden olur. zaman uyumsuz yöntemler BeginPeek ve BeginReceive, ana uygulama görevlerinin kuyruğa ileti ulaşana kadar ayrı bir iş parçacığında devam etmelerini sağlar. Bu yöntemler, iş parçacıkları arasında bilgi iletmek için geri çağırma nesnelerini ve durum nesnelerini kullanarak çalışır.

Sınıfının yeni bir örneğini MessageQueue oluşturduğunuzda, yeni bir Message Queuing kuyruğu oluşturmuyorsunuz. Bunun yerine, sunucudaki Create(String)kuyrukları yönetmek için , Delete(String)ve Purge yöntemlerini kullanabilirsiniz.

sürümünden Create(String) farklı Purgeolarak ve Delete(String) üyeleridirstatic, bu nedenle sınıfın MessageQueue yeni bir örneğini oluşturmadan bunları çağırabilirsiniz.

Nesnenin MessageQueuePath özelliğini üç addan biriyle ayarlayabilirsiniz: kolay ad, FormatNameveya Label. Kuyruğun ve özellikleri tarafından MachineName tanımlanan kolay ad,QueueName\MachineName genel bir kuyruk ve MachineNameQueueName\\Private$özel bir kuyruk içindir.QueueName özelliği, FormatName ileti kuyruklarına çevrimdışı erişim sağlar. Son olarak kuyruğun özelliğini kullanarak kuyruğun LabelPathözelliğini ayarlayabilirsiniz.

örneğinin ilk özellik değerlerinin MessageQueuelistesi için oluşturucuya MessageQueue bakın.

Oluşturucular

MessageQueue()	MessageQueue sınıfının yeni bir örneğini başlatır. Parametresiz oluşturucu yeni örneği başlatıldıktan sonra, örneği kullanabilmeniz için önce örneğin Path özelliğini ayarlamanız gerekir.
MessageQueue(String)	Belirtilen yolda Message Queuing kuyruğuna başvuran sınıfının yeni bir örneğini MessageQueue başlatır.
MessageQueue(String, Boolean)	Belirtilen yolda ve belirtilen okuma erişim kısıtlamasıyla Message Queuing kuyruğuna başvuran sınıfının yeni bir örneğini MessageQueue başlatır.
MessageQueue(String, Boolean, Boolean)	MessageQueue sınıfının yeni bir örneğini başlatır.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	MessageQueue sınıfının yeni bir örneğini başlatır.
MessageQueue(String, QueueAccessMode)	MessageQueue sınıfının yeni bir örneğini başlatır.

Alanlar

InfiniteQueueSize	Kuyruk için boyut kısıtlaması olmadığını belirtir.
InfiniteTimeout	İletilere göz atan veya alan yöntemler için zaman aşımı olmadığını belirtir.

Özellikler

AccessMode	Kuyruk için erişim modunu gösteren bir değer alır.
Authenticate	Kuyruğun yalnızca kimliği doğrulanmış iletileri kabul edip etmediğini belirten bir değer alır veya ayarlar.
BasePriority	Message Queuing'in ortak kuyruğun iletilerini ağ üzerinden yönlendirmek için kullandığı temel önceliği alır veya ayarlar.
CanRaiseEvents	Bileşenin bir olay oluşturup oluşturamayacağını belirten bir değer alır. (Devralındığı yer: Component)
CanRead	okunup MessageQueue okunamayacağını gösteren bir değer alır.
CanWrite	yazılabilir olup olmadığını MessageQueue gösteren bir değer alır.
Category	Kuyruk kategorisini alır veya ayarlar.
Container	öğesini IContainer içeren öğesini Componentalır. (Devralındığı yer: Component)
CreateTime	Kuyruğun Message Queuing'de oluşturulduğu saati ve tarihi alır.
DefaultPropertiesToSend	Uygulama kuyruğa ileti gönderdiğinde varsayılan olarak kullanılacak ileti özelliği değerlerini alır veya ayarlar.
DenySharedReceive	Bunun Message Queuing kuyruğundan ileti almak için özel erişime sahip olup olmadığını MessageQueue gösteren bir değer alır veya ayarlar.
DesignMode	öğesinin şu anda tasarım modunda olup olmadığını Component gösteren bir değer alır. (Devralındığı yer: Component)
EnableConnectionCache	Bir bağlantı önbelleğinin uygulama tarafından korunup tutulmayacağını belirten bir değer alır veya ayarlar.
EncryptionRequired	Kuyruğun yalnızca özel olmayan (şifrelenmemiş) iletileri kabul edip etmediğini belirten bir değer alır veya ayarlar.
Events	Bu Componentöğesine eklenen olay işleyicilerinin listesini alır. (Devralındığı yer: Component)
FormatName	Message Queuing'in kuyruğun oluşturulduğu sırada oluşturduğu benzersiz kuyruk adını alır.
Formatter	Bir nesneyi kuyruktan okunan veya kuyruğa yazılan ileti gövdesinden bir nesnenin içine seri hale getirmek veya seri durumdan kaldırmak için kullanılan biçimlendiriciyi alır veya ayarlar.
Id	Kuyruğun benzersiz Message Queuing tanımlayıcısını alır.
Label	Kuyruk açıklamasını alır veya ayarlar.
LastModifyTime	Kuyruğun özelliklerinin en son değiştirildiği zamanı alır.
MachineName	Message Queuing kuyruğunun bulunduğu bilgisayarın adını alır veya ayarlar.
MaximumJournalSize	Günlük kuyruğunun en büyük boyutunu alır veya ayarlar.
MaximumQueueSize	Kuyruğun en büyük boyutunu alır veya ayarlar.
MessageReadPropertyFilter	İletileri almak veya göz atmak için özellik filtresini alır veya ayarlar.
MulticastAddress	MSMQ 3.0'da kullanıma sunulmuştur. Kuyrukla ilişkili çok noktaya yayın adresini alır veya ayarlar.
Path	Kuyruğun yolunu alır veya ayarlar. ayarının Path ayarlanması, öğesinin MessageQueue yeni bir kuyruğa işaret etmesine neden olur.
QueueName	Kuyruğu tanımlayan kolay adı alır veya ayarlar.
ReadHandle	İleti kuyruğundan iletileri okumak için kullanılan yerel tanıtıcıyı alır.
Site	öğesini alır veya ayarlar ISiteComponent. (Devralındığı yer: Component)
SynchronizingObject	Bir veya olayından kaynaklanan olay işleyicisi çağrısını sıralayan ReceiveCompleted nesneyi alır veya PeekCompleted ayarlar.
Transactional	Kuyruğun yalnızca işlemleri kabul edip etmediğini belirten bir değer alır.
UseJournalQueue	Alınan iletilerin günlük kuyruğuna kopyalanıp kopyalanmayacağını gösteren bir değer alır veya ayarlar.
WriteHandle	İleti kuyruğuna ileti göndermek için kullanılan yerel tanıtıcıyı alır.

Yöntemler

BeginPeek()	Zaman aşımı olmayan zaman uyumsuz bir göz atma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene kadar işlem tamamlanmaz.
BeginPeek(TimeSpan)	Belirtilen zaman aşımına sahip zaman uyumsuz bir göz atma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	Belirtilen zaman aşımına sahip olan ve belirtilen bir imleç, belirtilen bir göz atma eylemi ve belirtilen bir durum nesnesi kullanan zaman uyumsuz bir göz atma işlemi başlatır. Durum nesnesi, işlemin ömrü boyunca ilişkili bilgiler sağlar. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginPeek(TimeSpan, Object)	Belirtilen zaman aşımına ve belirtilen durum nesnesine sahip olan ve işlemin ömrü boyunca ilişkili bilgiler sağlayan zaman uyumsuz bir göz atma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginPeek(TimeSpan, Object, AsyncCallback)	Belirtilen zaman aşımına ve belirtilen durum nesnesine sahip olan ve işlemin ömrü boyunca ilişkili bilgiler sağlayan zaman uyumsuz bir göz atma işlemi başlatır. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginReceive()	Zaman aşımı olmayan zaman uyumsuz bir alma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene kadar işlem tamamlanmaz.
BeginReceive(TimeSpan)	Belirtilen zaman aşımına sahip zaman uyumsuz alma işlemini başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	Belirtilen zaman aşımına sahip olan ve belirtilen bir imleç ile belirtilen durum nesnesini kullanan zaman uyumsuz bir alma işlemi başlatır. Durum nesnesi, işlemin ömrü boyunca ilişkili bilgiler sağlar. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginReceive(TimeSpan, Object)	İşlemin ömrü boyunca ilişkili bilgiler sağlayan, belirtilen zaman aşımına ve belirtilen durum nesnesine sahip zaman uyumsuz bir alma işlemi başlatır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
BeginReceive(TimeSpan, Object, AsyncCallback)	İşlemin ömrü boyunca ilişkili bilgiler sağlayan, belirtilen zaman aşımına ve belirtilen durum nesnesine sahip zaman uyumsuz bir alma işlemi başlatır. Bu aşırı yükleme, işlem için olay işleyicisinin kimliğine ilişkin bir geri çağırma yoluyla bildirim alır. kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı oluşana kadar işlem tamamlanmaz.
ClearConnectionCache()	Bağlantı önbelleğini temizler.
Close()	tarafından MessageQueueayrılan tüm kaynakları serbesttir.
Create(String)	Belirtilen yolda işlem dışı bir Message Queuing kuyruğu oluşturur.
Create(String, Boolean)	Belirtilen yolda işlemsel veya işlem dışı bir Message Queuing kuyruğu oluşturur.
CreateCursor()	Geçerli ileti kuyruğu için yeni Cursor bir oluşturur.
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Delete(String)	Message Queuing sunucusundaki bir kuyruğu siler.
Dispose()	Component tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Component)
Dispose(Boolean)	tarafından kullanılan kaynakları (bellek dışında) atılır MessageQueue.
EndPeek(IAsyncResult)	Belirtilen zaman uyumsuz göz atma işlemini tamamlar.
EndReceive(IAsyncResult)	Belirtilen zaman uyumsuz alma işlemini tamamlar.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
Exists(String)	Belirtilen yolda bir Message Queuing kuyruğu olup olmadığını belirler.
GetAllMessages()	Kuyruktaki tüm iletileri döndürür.
GetEnumerator()	Geçersiz. Kuyruktaki iletileri numaralandırır. GetEnumerator() kullanım dışı bırakıldı. GetMessageEnumerator2() yerine kullanılmalıdır.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetMachineId(String)	Bu MessageQueue tarafından başvurulan kuyruğun bulunduğu bilgisayarın tanımlayıcısını alır.
GetMessageEnumerator()	Geçersiz. Kuyruktaki tüm iletiler için bir numaralandırıcı nesnesi oluşturur. GetMessageEnumerator() kullanım dışı bırakıldı. GetMessageEnumerator2() yerine kullanılmalıdır.
GetMessageEnumerator2()	Kuyruktaki tüm iletiler için bir numaralandırıcı nesnesi oluşturur.
GetMessageQueueEnumerator()	Ağdaki tüm genel kuyrukları listelemek için yalnızca ileriye dönük imleç semantiği sağlar.
GetMessageQueueEnumerator(MessageQueueCriteria)	Ağdaki belirtilen ölçütlere uyan tüm genel kuyrukları listelemek için yalnızca ileriye dönük imleç semantiği sağlar.
GetPrivateQueuesByMachine(String)	Belirtilen bilgisayardaki tüm özel kuyrukları alır.
GetPublicQueues()	Ağdaki tüm genel kuyrukları alır.
GetPublicQueues(MessageQueueCriteria)	Ağdaki belirtilen ölçütleri karşılayan tüm genel kuyrukları alır.
GetPublicQueuesByCategory(Guid)	Ağdaki belirtilen kategoriye ait olan tüm genel kuyrukları alır.
GetPublicQueuesByLabel(String)	Belirtilen etiketi taşıyan ağdaki tüm genel kuyrukları alır.
GetPublicQueuesByMachine(String)	Belirtilen bilgisayarda bulunan tüm genel kuyrukları alır.
GetSecurityContext()	Msmq'nun bu çağrı sırasında geçerli kullanıcıyla (iş parçacığı kimliği) ilişkilendirir güvenlik bağlamını alır.
GetService(Type)	veya tarafından ComponentContainersağlanan bir hizmeti temsil eden bir nesnesi döndürür. (Devralındığı yer: Component)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
Peek()	Bu MessageQueuetarafından başvuruda bulunan kuyruktaki ilk iletiyi kaldırmadan (özetler) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene kadar geçerli iş parçacığını engeller.
Peek(TimeSpan)	Bu MessageQueuetarafından başvuruda bulunan kuyruktaki ilk iletiyi kaldırmadan (özetler) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene veya belirtilen zaman aşımı gerçekleşene kadar geçerli iş parçacığını engeller.
Peek(TimeSpan, Cursor, PeekAction)	Belirtilen imleci kullanarak kuyruktaki geçerli veya sonraki iletiyi kaldırmadan (göz atmadan) döndürür. Peek() yöntemi zaman uyumlu olduğundan, bir ileti kullanılabilir duruma gelene veya belirtilen zaman aşımı gerçekleşene kadar geçerli iş parçacığını engeller.
PeekByCorrelationId(String)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiye göz atarak kuyrukta belirtilen bağıntı tanımlayıcısı olan bir ileti yoksa hemen bir özel durum oluşturur.
PeekByCorrelationId(String, TimeSpan)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiye göz atıp belirtilen bağıntı tanımlayıcısını içeren bir ileti kuyrukta kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
PeekById(String)	İleti tanımlayıcısı parametresiyle eşleşen iletiyi özetler id .
PeekById(String, TimeSpan)	İleti tanımlayıcısı parametresiyle eşleşen iletiyi özetler id . İleti kuyrukta görünene veya zaman aşımı oluşana kadar bekler.
PeekByLookupId(Int64)	MSMQ 3.0'da kullanıma sunulmuştur. İşlem dışı bir kuyruktan verilen arama tanımlayıcısı ile eşleşen iletiye göz atarak.
PeekByLookupId(MessageLookupAction, Int64)	MSMQ 3.0'da kullanıma sunulmuştur. Kuyruktan belirli bir iletiye göz atarak. İleti bir arama tanımlayıcısı tarafından veya kuyruğun önündeki veya sonundaki konumuyla belirtilebilir.
Purge()	Kuyruktaki tüm iletileri siler.
Receive()	tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.
Receive(MessageQueueTransaction)	tarafından MessageQueuebaşvuruda bulunulan işlem kuyruğunda bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.
Receive(MessageQueueTransactionType)	tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve bir ileti kullanılabilir olana kadar geçerli yürütme iş parçacığını engeller.
Receive(TimeSpan)	tarafından MessageQueue başvurulan kuyrukta bulunan ilk iletiyi alır ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, Cursor)	Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	Belirtilen bir imleç kullanarak kuyruktaki geçerli iletiyi alır. Kullanılabilir ileti yoksa, bu yöntem bir ileti kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, MessageQueueTransaction)	tarafından MessageQueue başvurulan işlem kuyruğunda bulunan ilk iletiyi alır ve kuyrukta bir ileti kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
Receive(TimeSpan, MessageQueueTransactionType)	tarafından MessageQueuebaşvuruda bulunulan kuyrukta bulunan ilk iletiyi alır. Bu çağrı zaman uyumludur ve kuyrukta bir ileti bulunana veya zaman aşımı süresi dolana kadar bekler.
ReceiveByCorrelationId(String)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır (işlem dışı bir kuyruktan) ve şu anda kuyrukta belirtilen bağıntı tanımlayıcısı olan bir ileti yoksa hemen bir özel durum oluşturur.
ReceiveByCorrelationId(String, MessageQueueTransaction)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır (işlem kuyruğundan) ve şu anda kuyrukta belirtilen bağıntı tanımlayıcısı olan bir ileti yoksa hemen bir özel durum oluşturur.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır ve şu anda kuyrukta belirtilen bağıntı tanımlayıcısı olan bir ileti yoksa hemen bir özel durum oluşturur.
ReceiveByCorrelationId(String, TimeSpan)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır (işlem dışı bir kuyruktan) ve belirtilen bağıntı tanımlayıcısı olan bir ileti kuyrukta kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır (işlem kuyruğundan) ve belirtilen bağıntı tanımlayıcısı olan bir ileti kuyrukta kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır ve belirtilen bağıntı tanımlayıcısı olan bir ileti kuyrukta kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
ReceiveById(String)	İşlem dışı bir kuyruktan verilen tanımlayıcıyla eşleşen iletiyi alır ve şu anda kuyrukta belirtilen tanımlayıcıya sahip bir ileti yoksa hemen bir özel durum oluşturur.
ReceiveById(String, MessageQueueTransaction)	Verilen tanımlayıcıyla eşleşen iletiyi alır (işlem kuyruğundan) ve şu anda kuyrukta belirtilen tanımlayıcıya sahip bir ileti yoksa hemen bir özel durum oluşturur.
ReceiveById(String, MessageQueueTransactionType)	Verilen tanımlayıcıyla eşleşen iletiyi alır ve şu anda kuyrukta belirtilen tanımlayıcıya sahip bir ileti yoksa hemen bir özel durum oluşturur.
ReceiveById(String, TimeSpan)	Verilen tanımlayıcıyla eşleşen iletiyi alır (işlem dışı bir kuyruktan) ve belirtilen tanımlayıcıya sahip bir ileti kuyrukta kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	Verilen tanımlayıcıyla eşleşen iletiyi alır (işlem kuyruğundan) ve belirtilen tanımlayıcıya sahip bir ileti kuyrukta kullanılabilir olana veya zaman aşımı süresi dolana kadar bekler.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	Verilen tanımlayıcıyla eşleşen iletiyi alır ve belirtilen tanımlayıcıya sahip bir ileti kuyrukta kullanılabilir duruma gelene veya zaman aşımı süresi dolana kadar bekler.
ReceiveByLookupId(Int64)	MSMQ 3.0'da kullanıma sunulmuştur. İşlem dışı bir kuyruktan verilen arama tanımlayıcısı ile eşleşen iletiyi alır.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	MSMQ 3.0'da kullanıma sunulmuştur. İşlem kuyruğundan belirli bir ileti alır. İleti bir arama tanımlayıcısı tarafından veya kuyruğun önündeki veya sonundaki konumuyla belirtilebilir.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	MSMQ 3.0'da kullanıma sunulmuştur. Belirtilen işlem bağlamını kullanarak kuyruktan belirli bir ileti alır. İleti bir arama tanımlayıcısı tarafından veya kuyruğun önündeki veya sonundaki konumuyla belirtilebilir.
Refresh()	tarafından MessageQueue sunulan özellikleri, kaynağın geçerli durumunu yansıtacak şekilde yeniler.
ResetPermissions()	İzin listesini işletim sisteminin varsayılan değerlerine sıfırlar. Varsayılan listeye eklediğiniz tüm kuyruk izinlerini kaldırır.
Send(Object)	Bu MessageQueuetarafından başvurulan işlem dışı kuyruğa bir nesne gönderir.
Send(Object, MessageQueueTransaction)	Bu MessageQueuetarafından başvuruda bulunan işlem kuyruğuna bir nesne gönderir.
Send(Object, MessageQueueTransactionType)	Bu MessageQueuetarafından başvuruda bulunan kuyruğa bir nesne gönderir.
Send(Object, String)	Bu MessageQueue tarafından başvurulan işlem dışı kuyruğa bir nesne gönderir ve ileti için bir etiket belirtir.
Send(Object, String, MessageQueueTransaction)	Bu MessageQueue tarafından başvuruda bulunan işlem kuyruğuna bir nesne gönderir ve ileti için bir etiket belirtir.
Send(Object, String, MessageQueueTransactionType)	Bu MessageQueue tarafından başvuruda bulunan kuyruğa bir nesne gönderir ve ileti için bir etiket belirtir.
SetPermissions(AccessControlList)	Erişim denetim listesinin içeriğine göre kuyruğa erişim hakları atar.
SetPermissions(MessageQueueAccessControlEntry)	Erişim denetimi girdisinin içeriğine göre kuyruğa erişim hakları atar.
SetPermissions(String, MessageQueueAccessRights)	Bir bilgisayara, gruba veya kullanıcıya belirtilen erişim haklarını verir.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	Bir bilgisayara, gruba veya kullanıcıya belirtilen erişim denetim türüyle (izin ver, reddet, iptal et veya ayarla) belirtilen erişim haklarını verir.
ToString()	Varsa, adını Componentiçeren bir String döndürür. Bu yöntem geçersiz kılınmamalıdır. (Devralındığı yer: Component)

Ekinlikler

Disposed	Bileşen yöntemine Dispose() yapılan bir çağrı tarafından atıldığında gerçekleşir. (Devralındığı yer: Component)
PeekCompleted	Bir ileti kuyruktan kaldırılmadan okunduğunda gerçekleşir. Bu, zaman uyumsuz işleminin BeginPeek()sonucudur.
ReceiveCompleted	Kuyruktan bir ileti kaldırıldığında gerçekleşir. Bu olay, zaman uyumsuz işlemi BeginReceive()tarafından oluşturulur.

Uzantı Metotları

Cast<TResult>(IEnumerable)	öğesinin IEnumerable öğelerini belirtilen türe atar.
OfType<TResult>(IEnumerable)	Öğesinin IEnumerable öğelerini belirtilen türe göre filtreler.
AsParallel(IEnumerable)	Sorgunun paralelleştirilmesini etkinleştirir.
AsQueryable(IEnumerable)	bir IEnumerable öğesini öğesine IQueryabledönüştürür.

İş Parçacığı Güvenliği

GetAllMessages() Yalnızca yöntem iş parçacığı güvenlidir.

Ayrıca bkz.

• Message
• DefaultPropertiesToSend
• MessageQueueException
• MessageQueue()
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()
• Path
• Label
• FormatName
• QueueName
• MachineName