MessageQueue Sınıf
Tanım
Önemli
Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.
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))]
public 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))>]
type MessageQueue = class
inherit Component
interface IEnumerable[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
inherit Component
interface IEnumerablePublic Class MessageQueue
Inherits Component
Implements IEnumerable- Devralma
- Öznitelikler
- Uygulamalar
Ö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 göz atır (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ın MessageQueue kullanılması, kullandığınız işletim sistemine bağlı olarak biraz farklı davranışlara neden olabilir.
sınıfı Message MessageQueue 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 yeni bir iletinin kuyruğa ulaşması için işlem iş parçacığının belirli bir zaman aralığı beklemesine neden olur. ve BeginReceivezaman uyumsuz yöntemleri, BeginPeek kuyruğa bir ileti ulaşana kadar ana uygulama görevlerinin 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, FormatName, veya Label. Kuyruğun ve özellikleri tarafından tanımlanan kolay ad,QueueName\MachineName genel bir kuyruk vePrivate$\QueueNameMachineName\özel bir kuyruk içindir.QueueNameMachineName özelliği, FormatName ileti kuyruklarına çevrimdışı erişim sağlar. Son olarak kuyruğun özelliğini kullanarak kuyruğun LabelPathdeğerini 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 tanıtıldı. Kuyrukla ilişkili çok noktaya yayın adresini alır veya ayarlar. |
| Path |
Kuyruğun yolunu alır veya ayarlar. ayarının ayarlanması, öğesinin PathMessageQueue 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 kopyalanmadığını belirten 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() |
Geçersiz.
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() |
Geçersiz.
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 (göz atmadan) 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 (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ı oluşana 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ı oluşana 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ıyla ilgili 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ı olan 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 iletiye |
| PeekById(String, TimeSpan) |
İleti tanımlayıcısı parametresiyle eşleşen iletiye |
| PeekByLookupId(Int64) |
MSMQ 3.0'da tanıtıldı. İş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 tanıtıldı. 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 kullanılabilir duruma gelene 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 kuyrukta belirtilen bağıntı tanımlayıcısıyla ilgili 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 belirtilen bağıntı tanımlayıcısı şu anda kuyrukta mevcut değilse hemen bir özel durum oluşturur. |
| ReceiveByCorrelationId(String, MessageQueueTransactionType) |
Verilen bağıntı tanımlayıcısıyla eşleşen iletiyi alır ve belirtilen bağıntı tanımlayıcısı şu anda kuyrukta mevcut değilse 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 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 kuyrukta belirtilen tanımlayıcıya sahip bir ileti yoksa hemen bir özel durum oluşturur. |
| ReceiveById(String, MessageQueueTransactionType) |
Belirtilen tanımlayıcıyla eşleşen iletiyi alır ve 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 olana 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 tanıtıldı. İş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 tanıtıldı. İşlem kuyruğundan belirli bir iletiyi 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 tanıtıldı. 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şlemsel olmayan kuyruğa bir nesne gönderir. |
| Send(Object, MessageQueueTransaction) |
Bu MessageQueuetarafından başvuruda bulunan işlem kuyruğuna bir nesnesi gönderir. |
| Send(Object, MessageQueueTransactionType) |
Bu MessageQueuetarafından başvuruda bulunan kuyruğa bir nesnesi gönderir. |
| Send(Object, String) |
Bu MessageQueue tarafından başvurulan işlemsel olmayan 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. |
Şunlara uygulanır
İş Parçacığı Güvenliği
GetAllMessages() Yalnızca yöntemi iş parçacığı güvenlidir.
