MessageQueue.Send Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Messaging

Zestaw:: System.Messaging.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Wysyła obiekt do kolejki.

Przeciążenia

Send(Object)	Wysyła obiekt do kolejki innej niż transakcyjna, do których odwołuje się ten MessageQueueobiekt .
Send(Object, MessageQueueTransaction)	Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ten MessageQueueobiekt .
Send(Object, MessageQueueTransactionType)	Wysyła obiekt do kolejki, do których odwołuje się ten MessageQueueobiekt .
Send(Object, String)	Wysyła obiekt do kolejki innej niż transakcyjna, do których odwołuje się ta MessageQueue funkcja, i określa etykietę komunikatu.
Send(Object, String, MessageQueueTransaction)	Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ta MessageQueue funkcja, i określa etykietę komunikatu.
Send(Object, String, MessageQueueTransactionType)	Wysyła obiekt do kolejki, do których odwołuje się ta MessageQueue funkcja, i określa etykietę komunikatu.

Send(Object)

Wysyła obiekt do kolejki innej niż transakcyjna, do których odwołuje się ten MessageQueueobiekt .

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

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

Parametry

obj: Object

Obiekt do wysłania do kolejki.

Wyjątki

MessageQueueException

Właściwość nie została ustawiona Path .

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu łączy się z kolejką komunikatów i wysyła komunikat do kolejki.

#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

Poniższy przykład kodu wysyła klasę zdefiniowaną przez Order aplikację do kolejki, a następnie odbiera komunikat z tej kolejki.

Uwagi

Użyj tego przeciążenia, aby wysłać komunikat zawierający obj parametr do kolejki, do którego MessageQueueodwołuje się . Obiekt wysyłany do kolejki może być obiektem zarządzanym lub dowolnym obiektem zarządzanym Message . W przypadku wysyłania dowolnego obiektu innego Messageniż obiekt jest serializowany i wstawiony do treści komunikatu.

Jeśli używasz tego przeciążenia do wysyłania komunikatu do kolejki transakcyjnej, wiadomość zostanie wysłana do kolejki utraconych wiadomości. Jeśli chcesz, aby komunikat był częścią transakcji zawierającej inne komunikaty, użyj przeciążenia, które przyjmuje MessageQueueTransaction parametr lub MessageQueueTransactionType jako parametr.

Jeśli właściwość nie zostanie ustawiona Formatter przed wywołaniem metody Send(Object), formater domyślnie ustawi wartość XmlMessageFormatter.

Właściwość DefaultPropertiesToSend ma zastosowanie do dowolnego obiektu innego Messageniż . Jeśli określisz na przykład etykietę lub priorytet przy użyciu DefaultPropertiesToSend elementu członkowskiego, te wartości mają zastosowanie do dowolnego komunikatu zawierającego obiekt, który nie jest typu Message , gdy aplikacja wyśle ją do kolejki. Podczas wysyłania Messagewartości właściwości ustawione dla Message właściwości mają pierwszeństwo DefaultPropertiesToSend , a właściwość komunikatu Message.Formatter ma pierwszeństwo przed właściwością MessageQueue.Formatter kolejki.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

Send(Object, MessageQueueTransaction)

Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ten MessageQueueobiekt .

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)

Parametry

obj: Object

Obiekt do wysłania do kolejki.

transaction: MessageQueueTransaction

Obiekt MessageQueueTransaction.

Wyjątki

ArgumentNullException

Parametr transaction to null.

MessageQueueException

Właściwość nie została ustawiona Path .

-lub-

Aplikacja kolejkowania komunikatów wskazała nieprawidłowe użycie transakcji.

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

Poniższy przykład kodu wysyła ciąg do kolejki transakcyjnej, a następnie odbiera komunikat z tej kolejki.

#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

Uwagi

Użyj tego przeciążenia, aby wysłać komunikat zawierający obj parametr do kolejki transakcyjnej, MessageQueuedo którego odwołuje się parametr , przy użyciu wewnętrznego kontekstu transakcji zdefiniowanego transaction przez parametr . Obiekt wysyłany do kolejki może być obiektem zarządzanym lub dowolnym obiektem zarządzanym Message . W przypadku wysyłania dowolnego obiektu innego Messageniż obiekt jest serializowany i wstawiony do treści komunikatu.

Jeśli to przeciążenie jest używane do wysyłania komunikatu do kolejki innej niż transakcyjna, komunikat może zostać wysłany do kolejki utraconych wiadomości bez zgłaszania wyjątku.

Jeśli właściwość nie zostanie ustawiona Formatter przed wywołaniem metody Send(Object), formater domyślnie ustawi wartość XmlMessageFormatter.

MessageQueueTransaction jest wątkowa obsługa mieszkania, więc jeśli stan mieszkania to STA, nie można użyć transakcji w wielu wątkach. Program Visual Basic ustawia stan wątku głównego na STAwartość , więc należy zastosować element MTAThreadAttribute w Main podroutynie. W przeciwnym razie wysłanie komunikatu transakcyjnego przy użyciu innego wątku zgłasza MessageQueueException wyjątek. Zastosuj element MTAThreadAttribute przy użyciu następującego fragmentu.

<System.MTAThreadAttribute>
 public sub Main()

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

Send(Object, MessageQueueTransactionType)

Wysyła obiekt do kolejki, do których odwołuje się ten MessageQueueobiekt .

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)

Parametry

obj: Object

Obiekt do wysłania do kolejki.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType Jedna z wartości opisujących typ kontekstu transakcji do skojarzenia z komunikatem.

Wyjątki

InvalidEnumArgumentException

Parametr transactionType nie jest jednym z MessageQueueTransactionType elementów członkowskich.

MessageQueueException

Właściwość nie została ustawiona Path .

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

Użyj tego przeciążenia, aby wysłać komunikat zawierający obj parametr do kolejki, MessageQueuedo którego odwołuje się parametr , przy użyciu kontekstu transakcji zdefiniowanego transactionType przez parametr . Określ Automatic parametr, transactionType jeśli istnieje już zewnętrzny kontekst transakcji dołączony do wątku, którego chcesz użyć do wysłania komunikatu. Określ Single , czy chcesz wysłać komunikat jako jedną transakcję wewnętrzną. Możesz określić None , czy chcesz wysłać komunikat transakcyjny do wątku innego niż transakcyjny.

Obiekt wysyłany do kolejki może być obiektem zarządzanym lub dowolnym obiektem zarządzanym Message . W przypadku wysyłania dowolnego obiektu innego Messageniż obiekt jest serializowany i wstawiony do treści komunikatu.

Jeśli właściwość nie zostanie ustawiona Formatter przed wywołaniem metody Send(Object), formater domyślnie ustawi wartość XmlMessageFormatter.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

Send(Object, String)

Wysyła obiekt do kolejki nie transakcyjnej, do których odwołuje się ten MessageQueue komunikat, i określa etykietę komunikatu.

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)

Parametry

obj: Object

Obiekt do wysłania do kolejki.

label: String

Etykieta wiadomości.

Wyjątki

ArgumentNullException

Parametr label ma wartość null.

MessageQueueException

Właściwość nie została ustawiona Path .

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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");

Uwagi

Użyj tego przeciążenia, aby wysłać komunikat zawierający obj parametr do kolejki, do którego MessageQueueodwołuje się element . Za pomocą tego przeciążenia można określić etykietę ciągu, która identyfikuje komunikat. Obiekt wysyłany do kolejki może być strukturą Message, obiektem danych lub dowolnym zarządzanym obiektem. Jeśli wysyłasz dowolny obiekt inny niż Message, obiekt jest serializowany i wstawiany do treści komunikatu.

Etykieta komunikatu różni się od etykiety kolejki komunikatów, ale obie są zależne od aplikacji i nie mają dziedziczenia znaczenia dla kolejkowania komunikatów.

Jeśli używasz tego przeciążenia do wysyłania komunikatu do kolejki transakcyjnej, komunikat zostanie wysłany do kolejki utraconych komunikatów. Jeśli chcesz, aby komunikat był częścią transakcji zawierającej inne komunikaty, użyj przeciążenia, które przyjmuje MessageQueueTransaction parametr lub MessageQueueTransactionType .

Przed Path wysłaniem komunikatu należy określić właściwość dla tego MessageQueue wystąpienia. Jeśli właściwość nie zostanie ustawiona Formatter przed wywołaniem metody Send(Object), parametr formatujący domyślnie ma wartość XmlMessageFormatter.

Właściwość DefaultPropertiesToSend ma zastosowanie do dowolnego obiektu innego Messageniż . Jeśli określisz na przykład etykietę lub priorytet przy użyciu DefaultPropertiesToSend elementu członkowskiego, te wartości mają zastosowanie do dowolnego komunikatu zawierającego obiekt, który nie jest typu Message , gdy aplikacja wysyła ją do kolejki. Podczas wysyłania Messageobiektu wartości właściwości ustawione dla Message właściwości mają pierwszeństwo DefaultPropertiesToSend , a właściwość komunikatu Message.Formatter ma pierwszeństwo przed właściwością kolejki MessageQueue.Formatter .

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

Send(Object, String, MessageQueueTransaction)

Wysyła obiekt do kolejki transakcyjnej, do których odwołuje się ten MessageQueue komunikat, i określa etykietę komunikatu.

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)

Parametry

obj: Object

Obiekt do wysłania do kolejki.

label: String

Etykieta wiadomości.

transaction: MessageQueueTransaction

Obiekt MessageQueueTransaction.

Wyjątki

ArgumentNullException

Parametr label ma wartość null.

-lub-

Parametr transaction ma wartość null.

MessageQueueException

Właściwość nie została ustawiona Path .

-lub-

Aplikacja kolejkowania komunikatów wskazała nieprawidłowe użycie transakcji.

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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();
}

Uwagi

To przeciążenie służy do wysyłania komunikatu zawierającego obj parametr do kolejki transakcyjnej, do którego odwołuje się MessageQueueparametr , przy użyciu wewnętrznego kontekstu transakcji zdefiniowanego transaction przez parametr . Za pomocą tego przeciążenia można określić etykietę ciągu, która identyfikuje komunikat. Obiekt wysyłany do kolejki może być strukturą Message, obiektem danych lub dowolnym zarządzanym obiektem. Jeśli wysyłasz dowolny obiekt inny niż Message, obiekt jest serializowany i wstawiany do treści komunikatu.

Etykieta komunikatu różni się od etykiety kolejki komunikatów, ale obie są zależne od aplikacji i nie mają dziedziczenia znaczenia dla kolejkowania komunikatów.

Jeśli używasz tego przeciążenia do wysyłania komunikatu do kolejki nie transakcyjnej, komunikat może zostać wysłany do kolejki utraconych komunikatów bez zgłaszania wyjątku.

Jeśli właściwość nie zostanie ustawiona Formatter przed wywołaniem metody Send(Object), parametr formatujący domyślnie ma wartość XmlMessageFormatter.

Właściwość DefaultPropertiesToSend ma zastosowanie do dowolnego obiektu innego Messageniż . Jeśli określisz na przykład etykietę lub priorytet przy użyciu DefaultPropertiesToSend elementu członkowskiego, te wartości mają zastosowanie do dowolnego komunikatu zawierającego obiekt, który nie jest typu Message , gdy aplikacja wysyła ją do kolejki. Podczas wysyłania Messageobiektu wartości właściwości ustawione dla Message właściwości mają pierwszeństwoDefaultPropertiesToSend, a właściwość komunikatu Message.Formatter ma pierwszeństwo przed właściwością kolejki MessageQueue.Formatter

MessageQueueTransaction program obsługuje wątki mieszkania, więc jeśli stan mieszkania to STA, nie można użyć transakcji w wielu wątkach. Visual Basic ustawia stan głównego wątku na STA, więc należy zastosować element MTAThreadAttribute w podproceducji Main . W przeciwnym razie wysłanie komunikatu transakcyjnego przy użyciu innego wątku zgłasza MessageQueueException wyjątek. Zastosuj ten element MTAThreadAttribute przy użyciu następującego fragmentu.

<System.MTAThreadAttribute>
 public sub Main()

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Nazwa komputera lokalnego i bezpośredniego formatu	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i bezpośredniego formatu	Tak

Zobacz też

Dotyczy

Send(Object, String, MessageQueueTransactionType)

Wysyła obiekt do kolejki, do których odwołuje się ta MessageQueue funkcja, i określa etykietę komunikatu.

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)

Parametry

obj: Object

Obiekt do wysłania do kolejki.

label: String

Etykieta wiadomości.

transactionType: MessageQueueTransactionType

MessageQueueTransactionType Jedna z wartości opisujących typ kontekstu transakcji do skojarzenia z komunikatem.

Wyjątki

ArgumentNullException

Parametr label ma wartość null.

MessageQueueTransaction

Aplikacja kolejkowania komunikatów wskazała nieprawidłowe użycie transakcji.

InvalidEnumArgumentException

Parametr transactionType nie jest jednym z MessageQueueTransactionType elementów członkowskich.

MessageQueueException

Właściwość nie została ustawiona Path .

-lub-

Wystąpił błąd podczas uzyskiwania dostępu do metody kolejkowania komunikatów.

Przykłady

W poniższym przykładzie kodu pokazano użycie metody 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);

Uwagi

To przeciążenie służy do wysyłania komunikatu zawierającego obj parametr do kolejki, MessageQueuedo którego odwołuje się parametr , przy użyciu kontekstu transakcji zdefiniowanego transactionType przez parametr . Określ Automatic parametr , transactionType jeśli istnieje już zewnętrzny kontekst transakcji dołączony do wątku, którego chcesz użyć do wysłania komunikatu. Określ Single , czy chcesz wysłać komunikat jako pojedynczą transakcję wewnętrzną. Możesz określić None , czy chcesz wysłać komunikat transakcyjny do wątku nie transakcyjnego.

Obiekt wysyłany do kolejki może być obiektem zarządzanym Message lub . Jeśli wysyłasz dowolny obiekt inny niż Message, obiekt jest serializowany i wstawiany do treści komunikatu. Za pomocą tego przeciążenia można określić etykietę ciągu, która identyfikuje komunikat.

Etykieta komunikatu różni się od etykiety kolejki komunikatów, ale obie są zależne od aplikacji i nie mają dziedziczenia znaczenia dla kolejkowania komunikatów.

Jeśli właściwość nie zostanie ustawiona Formatter przed wywołaniem metody Send(Object), parametr formatujący domyślnie ma wartość XmlMessageFormatter.

Właściwość DefaultPropertiesToSend ma zastosowanie do dowolnego obiektu innego Messageniż . Jeśli określisz na przykład etykietę lub priorytet przy użyciu DefaultPropertiesToSend elementu członkowskiego, te wartości mają zastosowanie do dowolnego komunikatu zawierającego obiekt, który nie jest typu Message , gdy aplikacja wysyła ją do kolejki. Podczas wysyłania Messageelementu wartości właściwości ustawione dla Message właściwości mają pierwszeństwo DefaultPropertiesToSendprzed właściwością , a właściwość komunikatu Message.Formatter ma pierwszeństwo przed właściwością MessageQueue.Formatter kolejki.

W poniższej tabeli przedstawiono, czy ta metoda jest dostępna w różnych trybach grupy roboczej.

Tryb grupy roboczej	Dostępne
Komputer lokalny	Tak
Komputer lokalny i nazwa formatu bezpośredniego	Tak
Komputer zdalny	Nie
Nazwa komputera zdalnego i formatu bezpośredniego	Tak

Zobacz też

Dotyczy

Udostępnij za pośrednictwem

MessageQueue.Send Metoda

Definicja

Przeciążenia

Send(Object)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Send(Object, MessageQueueTransaction)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Send(Object, MessageQueueTransactionType)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Send(Object, String)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Send(Object, String, MessageQueueTransaction)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Send(Object, String, MessageQueueTransactionType)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

Dodatkowe zasoby