MessageQueue.Send Yöntem

Tanım

Ad Alanı:

System.Messaging

Bütünleştirilmiş Kod:

System.Messaging.dll

Bir nesneyi kuyruğa gönderir.

Aşırı Yüklemeler

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.

Send(Object)

Bu MessageQueuetarafından başvurulan işlem dışı kuyruğa bir nesne gönderir.

public:
 void Send(System::Object ^ obj);

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parametreler

obj

Object

Kuyruğa gönderilecek nesne.

Özel durumlar

MessageQueueException

Path özelliği ayarlanmadı.

-veya- Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği bir ileti kuyruğuna bağlanır ve kuyruğa bir ileti gönderir.

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

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
   void SendMessage()
   {
      
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      
      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
         
         // Begin the transaction.
         myTransaction->Begin();
         
         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );
         
         // Commit the transaction.
         myTransaction->Commit();
      }
      else
      {
         myQueue->Send( "My Message Data." );
      }

      return;
   }

};

int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Send a message to a queue.
   myNewQueue->SendMessage();
   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 sends a message to 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();

            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessage()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }
            else
            {
                myQueue.Send("My Message Data.");
            }

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        ' 
        ' This example sends a message to a queue.
        '

        Public Shared Sub Main()

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

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

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessage()

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

            ' Send a message to the queue.
            If myQueue.Transactional = True Then

                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()

            Else
                myQueue.Send("My Message Data.")
            End If

            Return

        End Sub

End Class

Aşağıdaki kod örneği, bir kuyruğa uygulama tanımlı Order bir sınıf gönderir ve ardından bu kuyruktan bir ileti alır.

Açıklamalar

parametresini içeren bir iletiyi tarafından MessageQueuebaşvuruda bulunan obj kuyruğa göndermek için bu aşırı yüklemeyi kullanın. Kuyruğa gönderdiğiniz nesne veya yönetilen herhangi bir Message nesne olabilir. dışında Messagebir nesne gönderirseniz, nesne serileştirilir ve iletinin gövdesine eklenir.

İşlem kuyruğuna ileti göndermek için bu aşırı yüklemeyi kullanırsanız, ileti teslim edilemeyen ileti kuyruğuna gönderilir. İletinin başka iletiler içeren bir işlemin parçası olmasını istiyorsanız, veya MessageQueueTransactionType parametresini alan MessageQueueTransaction bir aşırı yükleme kullanın.

özelliğini çağırmadan önce ayarlamazsanızFormatter, biçimlendirici varsayılan olarak olarak ayarlanırXmlMessageFormatter.Send(Object)

DefaultPropertiesToSend özelliği, dışında herhangi bir Messagenesne için geçerlidir. Örneğin, üyeyi DefaultPropertiesToSend kullanan bir etiket veya öncelik belirtirseniz, bu değerler uygulamanız kuyruğa gönderdiğinde türünde Message olmayan bir nesne içeren tüm iletilere uygulanır. gönderirkenMessage, öncelik için DefaultPropertiesToSend ayarlanan Message özellik değerleri ve iletinin Message.Formatter özelliği kuyruğun MessageQueue.Formatter özelliğinden önceliklidir.

Aşağıdaki tabloda, bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• DefaultPropertiesToSend
• Message
• Path
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, MessageQueueTransaction)

Bu MessageQueuetarafından başvuruda bulunan işlem kuyruğuna bir nesne gönderir.

public:
 void Send(System::Object ^ obj, System::Messaging::MessageQueueTransaction ^ transaction);

public void Send (object obj, System.Messaging.MessageQueueTransaction transaction);

member this.Send : obj * System.Messaging.MessageQueueTransaction -> unit

Public Sub Send (obj As Object, transaction As MessageQueueTransaction)

Parametreler

obj

Object

Kuyruğa gönderilecek nesne.

transaction

MessageQueueTransaction

MessageQueueTransaction nesnesi.

Özel durumlar

ArgumentNullException

transaction parametresidirnull.

MessageQueueException

Path özelliği ayarlanmadı.

-veya- Message Queuing uygulaması yanlış bir işlem kullanımı olduğunu gösteriyor.

-veya- Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneği işlem kuyruğuna bir dize gönderir ve ardından bu kuyruktan bir ileti alır.

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

using namespace System;
using namespace System::Messaging;

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

   //*************************************************
   // Sends a message to a queue.
   //*************************************************
   void SendMessageTransactional()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myTransactionalQueue" );

      // Send a message to the queue.
      if ( myQueue->Transactional == true )
      {
         // Create a transaction.
         MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;

         // Begin the transaction.
         myTransaction->Begin();

         // Send the message.
         myQueue->Send( "My Message Data.", myTransaction );

         // Commit the transaction.
         myTransaction->Commit();
      }

      return;
   }


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

      // Set the formatter.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );

      // Create a transaction.
      MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
      try
      {
         // Begin the transaction.
         myTransaction->Begin();

         // Receive the message. 
         Message^ myMessage = myQueue->Receive( myTransaction );
         String^ myOrder = static_cast<String^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( myOrder );

         // Commit the transaction.
         myTransaction->Commit();
      }
      catch ( MessageQueueException^ e ) 
      {
         // Handle nontransactional queues.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::TransactionUsage )
         {
            Console::WriteLine( "Queue is not transactional." );
         }

         // Else catch other sources of MessageQueueException.
         // Roll back the transaction.
         myTransaction->Abort();
      }

      // Catch other exceptions as necessary, such as 
      // InvalidOperationException, thrown when the formatter 
      // cannot deserialize the message.
      return;
   }
};

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

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

   // Receive a message from a queue.
   myNewQueue->ReceiveMessageTransactional();
   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 sends and receives a message from
        // a transactional queue.
        //**************************************************

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

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

            // Receive a message from a queue.
            myNewQueue.ReceiveMessageTransactional();
        
            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessageTransactional()
        {
                        
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new
                MessageQueue(".\\myTransactionalQueue");

            // Send a message to the queue.
            if (myQueue.Transactional == true)
            {
                // Create a transaction.
                MessageQueueTransaction myTransaction = new
                    MessageQueueTransaction();

                // Begin the transaction.
                myTransaction.Begin();

                // Send the message.
                myQueue.Send("My Message Data.", myTransaction);

                // Commit the transaction.
                myTransaction.Commit();
            }

            return;
        }

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

            // Set the formatter.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            // Create a transaction.
            MessageQueueTransaction myTransaction = new
                MessageQueueTransaction();

            try
            {
                // Begin the transaction.
                myTransaction.Begin();
                
                // Receive the message.
                Message myMessage =	myQueue.Receive(myTransaction);
                String myOrder = (String)myMessage.Body;

                // Display message information.
                Console.WriteLine(myOrder);

                // Commit the transaction.
                myTransaction.Commit();
            }
            
            catch (MessageQueueException e)
            {
                // Handle nontransactional queues.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.TransactionUsage)
                {
                    Console.WriteLine("Queue is not transactional.");
                }
                
                // Else catch other sources of MessageQueueException.

                // Roll back the transaction.
                myTransaction.Abort();
            }

            // Catch other exceptions as necessary, such as
            // InvalidOperationException, thrown when the formatter
            // cannot deserialize the message.

            return;
        }
    }
}

Imports System.Messaging

   
Public Class MyNewQueue


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

        Public Shared Sub Main()

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

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

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

            Return

        End Sub


        '
        ' Sends a message to a queue.
        '

        Public Sub SendMessageTransactional()

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

            ' Send a message to the queue.
            If myQueue.Transactional = True Then
                ' Create a transaction.
                Dim myTransaction As New MessageQueueTransaction

                ' Begin the transaction.
                myTransaction.Begin()

                ' Send the message.
                myQueue.Send("My Message Data.", myTransaction)

                ' Commit the transaction.
                myTransaction.Commit()
            End If

            Return

        End Sub


        '
        ' Receives a message containing an Order.
        '

        Public Sub ReceiveMessageTransactional()

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

            ' Set the formatter.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            ' Create a transaction.
            Dim myTransaction As New MessageQueueTransaction

            Try

                ' Begin the transaction.
                myTransaction.Begin()

                ' Receive the message. 
                Dim myMessage As Message = _
                    myQueue.Receive(myTransaction)
                Dim myOrder As [String] = CType(myMessage.Body, _
                    [String])

                ' Display message information.
                Console.WriteLine(myOrder)

                ' Commit the transaction.
                myTransaction.Commit()


            Catch e As MessageQueueException

                ' Handle nontransactional queues.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.TransactionUsage Then

                    Console.WriteLine("Queue is not transactional.")

                End If

                ' Else catch other sources of a MessageQueueException.


                ' Roll back the transaction.
                myTransaction.Abort()


                ' Catch other exceptions as necessary, such as 
                ' InvalidOperationException, thrown when the formatter
                ' cannot deserialize the message.

            End Try

            Return

        End Sub

End Class

Açıklamalar

parametresi tarafından tanımlanan transaction bir iç işlem bağlamını kullanarak parametresini obj tarafından başvuruda bulunan işlem kuyruğuna MessageQueueiçeren bir ileti göndermek için bu aşırı yüklemeyi kullanın. Kuyruğa gönderdiğiniz nesne veya yönetilen herhangi bir Message nesne olabilir. dışında Messagebir nesne gönderirseniz, nesne serileştirilir ve iletinin gövdesine eklenir.

İşlem dışı bir kuyruğa ileti göndermek için bu aşırı yüklemeyi kullanırsanız, ileti özel durum oluşturmadan teslim edilemeyen ileti kuyruğuna gönderilebilir.

özelliğini çağırmadan önce ayarlamazsanızFormatter, biçimlendirici varsayılan olarak olarak ayarlanırXmlMessageFormatter.Send(Object)

DefaultPropertiesToSend özelliği, dışında herhangi bir Messagenesne için geçerlidir. Örneğin, üyeyi DefaultPropertiesToSend kullanan bir etiket veya öncelik belirtirseniz, bu değerler uygulamanız kuyruğa gönderdiğinde türünde Message olmayan bir nesne içeren tüm iletilere uygulanır. gönderirkenMessage, öncelik için DefaultPropertiesToSend ayarlanan Message özellik değerleri ve iletinin Message.Formatter özelliği kuyruğun MessageQueue.Formatter özelliğinden önceliklidir.

MessageQueueTransaction iş parçacığı kullanan bir dairedir, bu nedenle daire durumunuz ise STAişlemi birden çok iş parçacığında kullanamazsınız. Visual Basic ana iş parçacığının durumunu olarak STAayarlar, bu nedenle öğesini alt yordama Main uygulamanız MTAThreadAttribute gerekir. Aksi takdirde, başka bir iş parçacığı kullanarak işlem iletisi göndermek bir MessageQueueException özel durum oluşturur. aşağıdaki parçayı kullanarak uygulamasınız MTAThreadAttribute .

<System.MTAThreadAttribute>  
 public sub Main()  

Aşağıdaki tabloda, bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• DefaultPropertiesToSend
• Message
• MessageQueueTransaction
• Transactional
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, MessageQueueTransactionType)

Bu MessageQueuetarafından başvuruda bulunan kuyruğa bir nesne gönderir.

public:
 void Send(System::Object ^ obj, System::Messaging::MessageQueueTransactionType transactionType);

public void Send (object obj, System.Messaging.MessageQueueTransactionType transactionType);

member this.Send : obj * System.Messaging.MessageQueueTransactionType -> unit

Public Sub Send (obj As Object, transactionType As MessageQueueTransactionType)

Parametreler

obj

Object

Kuyruğa gönderilecek nesne.

transactionType

MessageQueueTransactionType

MessageQueueTransactionType İletiyle ilişkilendirilecek işlem bağlamının türünü açıklayan değerlerden biri.

Özel durumlar

InvalidEnumArgumentException

transactionType parametresi üyelerden MessageQueueTransactionType biri değildir.

MessageQueueException

Path özelliği ayarlanmadı.

-veya- Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneğinde kullanımı gösterilmektedir Send(Object, MessageQueueTransactionType).

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

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, MessageQueueTransactionType::Single);

queue->Close();

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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, MessageQueueTransactionType.Single);

Açıklamalar

parametresi tarafından tanımlanan transactionType bir işlem bağlamını obj kullanarak tarafından başvuruda bulunan kuyruğa parametresini MessageQueueiçeren bir ileti göndermek için bu aşırı yüklemeyi kullanın. İletiyi transactionType göndermek için kullanmak istediğiniz iş parçacığına eklenmiş bir dış işlem bağlamı zaten varsa parametresini belirtinAutomatic. İletiyi tek bir iç işlem olarak göndermek isteyip istemediğinizi belirtin Single . İşlem dışı bir iş parçacığına işlem iletisi göndermek isteyip istemediğinizi belirtebilirsiniz None .

Kuyruğa gönderdiğiniz nesne veya yönetilen herhangi bir Message nesne olabilir. dışında Messagebir nesne gönderirseniz, nesne serileştirilir ve iletinin gövdesine eklenir.

özelliğini çağırmadan önce ayarlamazsanızFormatter, biçimlendirici varsayılan olarak olarak ayarlanırXmlMessageFormatter.Send(Object)

DefaultPropertiesToSend özelliği, dışında herhangi bir Messagenesne için geçerlidir. Örneğin, üyeyi DefaultPropertiesToSend kullanan bir etiket veya öncelik belirtirseniz, bu değerler uygulamanız kuyruğa gönderdiğinde türünde Message olmayan bir nesne içeren tüm iletilere uygulanır. gönderirkenMessage, öncelik için DefaultPropertiesToSend ayarlanan Message özellik değerleri ve iletinin Message.Formatter özelliği kuyruğun MessageQueue.Formatter özelliğinden önceliklidir.

Aşağıdaki tabloda, bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• MessageQueueTransactionType
• DefaultPropertiesToSend
• Message
• Transactional
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

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.

public:
 void Send(System::Object ^ obj, System::String ^ label);

public void Send (object obj, string label);

member this.Send : obj * string -> unit

Public Sub Send (obj As Object, label As String)

Parametreler

obj

Object

Kuyruğa gönderilecek nesne.

label

String

İletinin etiketi.

Özel durumlar

ArgumentNullException

label parametresidirnull.

MessageQueueException

Path özelliği ayarlanmadı.

-veya- Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneğinde kullanımı gösterilmektedir Send(Object, String).

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

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, "Example Message Label");

queue->Close();

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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, "Example Message Label");

Açıklamalar

parametresini içeren bir iletiyi tarafından MessageQueuebaşvuruda bulunan obj kuyruğa göndermek için bu aşırı yüklemeyi kullanın. Bu aşırı yüklemeyle, iletiyi tanımlayan dize etiketini belirtebilirsiniz. Kuyruğa gönderdiğiniz nesne bir Message, yapısı, veri nesnesi veya yönetilen herhangi bir nesne olabilir. dışında Messagebir nesne gönderirseniz, nesne serileştirilir ve iletinin gövdesine eklenir.

İleti etiketi ileti kuyruğu etiketinden farklıdır, ancak her ikisi de uygulamaya bağımlıdır ve Message Queuing'e hiçbir anlamı devralmaz.

İşlem kuyruğuna ileti göndermek için bu aşırı yüklemeyi kullanırsanız, ileti teslim edilemeyen ileti kuyruğuna gönderilir. İletinin başka iletiler içeren bir işlemin parçası olmasını istiyorsanız, veya MessageQueueTransactionType parametresini alan MessageQueueTransaction bir aşırı yükleme kullanın.

İletiyi Path göndermeden önce bu MessageQueue örneğin özelliği belirtilmelidir. özelliğini çağırmadan önce ayarlamazsanızFormatter, biçimlendirici varsayılan olarak olarak ayarlanırXmlMessageFormatter.Send(Object)

DefaultPropertiesToSend özelliği, dışında herhangi bir Messagenesne için geçerlidir. Örneğin, üyeyi DefaultPropertiesToSend kullanan bir etiket veya öncelik belirtirseniz, bu değerler uygulamanız kuyruğa gönderdiğinde türünde Message olmayan bir nesne içeren tüm iletilere uygulanır. gönderirkenMessage, öncelik için DefaultPropertiesToSend ayarlanan Message özellik değerleri ve iletinin Message.Formatter özelliği kuyruğun MessageQueue.Formatter özelliğinden önceliklidir.

Aşağıdaki tabloda, bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• DefaultPropertiesToSend
• Message
• Label
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

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.

public:
 void Send(System::Object ^ obj, System::String ^ label, System::Messaging::MessageQueueTransaction ^ transaction);

public void Send (object obj, string label, System.Messaging.MessageQueueTransaction transaction);

member this.Send : obj * string * System.Messaging.MessageQueueTransaction -> unit

Public Sub Send (obj As Object, label As String, transaction As MessageQueueTransaction)

Parametreler

obj

Object

Kuyruğa gönderilecek nesne.

label

String

İletinin etiketi.

transaction

MessageQueueTransaction

MessageQueueTransaction nesnesi.

Özel durumlar

ArgumentNullException

label parametresidirnull.

-veya- transaction parametresidirnull.

MessageQueueException

Path özelliği ayarlanmadı.

-veya- Message Queuing uygulaması yanlış bir işlem kullanımı olduğunu gösteriyor.

-veya- Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneğinde kullanımı gösterilmektedir Send(Object, String, MessageQueueTransaction).

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

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Create a message queuing transaction.
MessageQueueTransaction^ transaction = gcnew MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction->Begin();

    // Send the message to the queue.
    queue->Send(msg, "Example Message Label", transaction);

    // Commit the transaction.
    transaction->Commit();
}
catch (Exception^ ex)
{
    // Cancel the transaction.
    transaction->Abort();

    // Propagate the exception.
    throw ex;
}
finally
{
    // Dispose of the transaction object.
    delete transaction;
    queue->Close();
}

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

// Create a new message.
Message msg = new Message("Example Message Body");

// Create a message queuing transaction.
MessageQueueTransaction transaction = new MessageQueueTransaction();

try
{
    // Begin a transaction.
    transaction.Begin();

    // Send the message to the queue.
    queue.Send(msg, "Example Message Label", transaction);

    // Commit the transaction.
    transaction.Commit();
}
catch(System.Exception e)
{
    // Cancel the transaction.
    transaction.Abort();

    // Propagate the exception.
    throw e;
}
finally
{
    // Dispose of the transaction object.
    transaction.Dispose();
}

Açıklamalar

parametresi tarafından tanımlanan transaction bir iç işlem bağlamını kullanarak parametresini obj tarafından başvuruda bulunan işlem kuyruğuna MessageQueueiçeren bir ileti göndermek için bu aşırı yüklemeyi kullanın. Bu aşırı yüklemeyle, iletiyi tanımlayan dize etiketini belirtebilirsiniz. Kuyruğa gönderdiğiniz nesne bir Message, yapısı, veri nesnesi veya yönetilen herhangi bir nesne olabilir. dışında Messagebir nesne gönderirseniz, nesne serileştirilir ve iletinin gövdesine eklenir.

İleti etiketi ileti kuyruğu etiketinden farklıdır, ancak her ikisi de uygulamaya bağımlıdır ve Message Queuing'e hiçbir anlamı devralmaz.

İşlem dışı bir kuyruğa ileti göndermek için bu aşırı yüklemeyi kullanırsanız, ileti özel durum oluşturmadan teslim edilemeyen ileti kuyruğuna gönderilebilir.

özelliğini çağırmadan önce ayarlamazsanızFormatter, biçimlendirici varsayılan olarak olarak ayarlanırXmlMessageFormatter.Send(Object)

DefaultPropertiesToSend özelliği, dışında herhangi bir Messagenesne için geçerlidir. Örneğin, üyeyi DefaultPropertiesToSend kullanan bir etiket veya öncelik belirtirseniz, bu değerler uygulamanız kuyruğa gönderdiğinde türünde Message olmayan bir nesne içeren tüm iletilere uygulanır. gönderirkenMessage, öncelik için DefaultPropertiesToSend ayarlanan Message özellik değerleri ve iletinin Message.Formatter özelliği kuyruğun MessageQueue.Formatter özelliğinden önceliklidir

MessageQueueTransaction iş parçacığı kullanan bir dairedir, bu nedenle daire durumunuz ise STAişlemi birden çok iş parçacığında kullanamazsınız. Visual Basic ana iş parçacığının durumunu olarak STAayarlar, bu nedenle öğesini alt yordama Main uygulamanız MTAThreadAttribute gerekir. Aksi takdirde, başka bir iş parçacığı kullanarak işlem iletisi göndermek bir MessageQueueException özel durum oluşturur. aşağıdaki parçayı kullanarak uygulamasınız MTAThreadAttribute .

<System.MTAThreadAttribute>  
 public sub Main()  

Aşağıdaki tabloda, bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• DefaultPropertiesToSend
• Message
• MessageQueueTransaction
• Transactional
• Label
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()

Send(Object, String, MessageQueueTransactionType)

Bu MessageQueue tarafından başvuruda bulunan kuyruğa bir nesne gönderir ve ileti için bir etiket belirtir.

public:
 void Send(System::Object ^ obj, System::String ^ label, System::Messaging::MessageQueueTransactionType transactionType);

public void Send (object obj, string label, System.Messaging.MessageQueueTransactionType transactionType);

member this.Send : obj * string * System.Messaging.MessageQueueTransactionType -> unit

Public Sub Send (obj As Object, label As String, transactionType As MessageQueueTransactionType)

Parametreler

obj

Object

Kuyruğa gönderilecek nesne.

label

String

İletinin etiketi.

transactionType

MessageQueueTransactionType

MessageQueueTransactionType İletiyle ilişkilendirilecek işlem bağlamının türünü açıklayan değerlerden biri.

Özel durumlar

ArgumentNullException

label parametresidirnull.

MessageQueueTransaction

Message Queuing uygulaması yanlış bir işlem kullanımı olduğunu gösteriyor.

InvalidEnumArgumentException

transactionType parametresi üyelerden MessageQueueTransactionType biri değildir.

MessageQueueException

Path özelliği ayarlanmadı.

-veya- Message Queuing yöntemine erişilirken bir hata oluştu.

Örnekler

Aşağıdaki kod örneğinde kullanımı gösterilmektedir Send(Object, String, MessageQueueTransactionType).

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

// Create a new message.
Message^ msg = gcnew Message("Example Message Body");

// Send the message.
queue->Send(msg, "Example Message Label",
    MessageQueueTransactionType::Single);

queue->Close();

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

// Create a new message.
Message msg = new Message("Example Message Body");

// Send the message.
queue.Send(msg, "Example Message Label",
    MessageQueueTransactionType.Single);

Açıklamalar

parametresi tarafından tanımlanan transactionType bir işlem bağlamını obj kullanarak tarafından başvuruda bulunan kuyruğa parametresini MessageQueueiçeren bir ileti göndermek için bu aşırı yüklemeyi kullanın. İletiyi transactionType göndermek için kullanmak istediğiniz iş parçacığına eklenmiş bir dış işlem bağlamı zaten varsa parametresini belirtinAutomatic. İletiyi tek bir iç işlem olarak göndermek isteyip istemediğinizi belirtin Single . İşlem dışı bir iş parçacığına işlem iletisi göndermek isteyip istemediğinizi belirtebilirsiniz None .

Kuyruğa gönderdiğiniz nesne veya yönetilen herhangi bir Message nesne olabilir. dışında Messagebir nesne gönderirseniz, nesne serileştirilir ve iletinin gövdesine eklenir. Bu aşırı yüklemeyle, iletiyi tanımlayan dize etiketini belirtebilirsiniz.

İleti etiketi ileti kuyruğu etiketinden farklıdır, ancak her ikisi de uygulamaya bağımlıdır ve Message Queuing'e hiçbir anlamı devralmaz.

özelliğini çağırmadan önce ayarlamazsanızFormatter, biçimlendirici varsayılan olarak olarak ayarlanırXmlMessageFormatter.Send(Object)

DefaultPropertiesToSend özelliği, dışında herhangi bir Messagenesne için geçerlidir. Örneğin, üyeyi DefaultPropertiesToSend kullanan bir etiket veya öncelik belirtirseniz, bu değerler uygulamanız kuyruğa gönderdiğinde türünde Message olmayan bir nesne içeren tüm iletilere uygulanır. gönderirkenMessage, üzerinde öncelik DefaultPropertiesToSendiçin ayarlanan Message özellik değerleri ve iletinin Message.Formatter özelliği kuyruğun MessageQueue.Formatter özelliğinden önceliklidir.

Aşağıdaki tabloda, bu yöntemin çeşitli Çalışma Grubu modlarında kullanılabilir olup olmadığı gösterilmektedir.

Çalışma grubu modu	Kullanılabilir
Yerel bilgisayar	Yes
Yerel bilgisayar ve doğrudan biçim adı	Yes
Uzak bilgisayar	No
Uzak bilgisayar ve doğrudan biçim adı	Yes

Ayrıca bkz.

• MessageQueueTransactionType
• DefaultPropertiesToSend
• Message
• Transactional
• Label
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()