MessageQueue.Send 메서드

정의

네임스페이스:

System.Messaging

어셈블리:

System.Messaging.dll

큐에 개체를 보냅니다.

오버로드

Send(Object)	이 MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보냅니다.
Send(Object, MessageQueueTransaction)	이 MessageQueue가 참조하는 트랜잭션 큐에 개체를 보냅니다.
Send(Object, MessageQueueTransactionType)	이 MessageQueue가 참조하는 큐에 개체를 보냅니다.
Send(Object, String)	이 MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.
Send(Object, String, MessageQueueTransaction)	이 MessageQueue가 참조하는 트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.
Send(Object, String, MessageQueueTransactionType)	이 MessageQueue가 참조하는 큐에 개체를 보내고 메시지에 레이블을 지정합니다.

Send(Object)

이 MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보냅니다.

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

public void Send (object obj);

member this.Send : obj -> unit

Public Sub Send (obj As Object)

매개 변수

obj

Object

큐에 보낼 개체입니다.

예외

MessageQueueException

Path 속성이 설정되어 있지 않은 경우

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 메시지 큐에 연결 하 고 큐에 메시지를 보냅니다.

#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

다음 코드 예제에서는 애플리케이션 정의 보냅니다 Order 큐에 클래스 및 해당 큐에서 메시지를 받습니다.

설명

이 오버로드를 사용하여 매개 변수가 포함된 obj 메시지를 에서 참조하는 큐로 보냅니다 MessageQueue. 큐에 보내는 개체는 또는 관리되는 Message 개체일 수 있습니다. 이외의 개체를 Message보내면 개체가 직렬화되어 메시지 본문에 삽입됩니다.

이 오버로드를 사용하여 트랜잭션 큐에 메시지를 보내는 경우 메시지는 배달 못 한 편지 큐로 전송됩니다. 메시지가 다른 메시지를 포함하는 트랜잭션의 일부가 되도록 하려면 또는 MessageQueueTransactionType 를 매개 변수로 사용하는 MessageQueueTransaction 오버로드를 사용합니다.

를 호출Send(Object)하기 전에 속성을 설정 Formatter 하지 않으면 포맷터는 기본적으로 로 설정XmlMessageFormatter됩니다.

속성은 DefaultPropertiesToSend 이외의 개체 Message에 적용됩니다. 를 지정 하면 예를 들어, 레이블 또는 사용 하 여 우선 순위를 DefaultPropertiesToSend 멤버를이 값은 형식이 아닌 개체를 포함 하는 모든 메시지에 적용 Message 경우 애플리케이션 큐로 보냅니다는 합니다. 를 보낼 Message때 에 대해 Message 설정된 속성 값이 우선 DefaultPropertiesToSend 적으로 적용되고 메시지의 Message.Formatter 속성이 큐의 MessageQueue.Formatter 속성보다 우선합니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

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

Send(Object, MessageQueueTransaction)

이 MessageQueue가 참조하는 트랜잭션 큐에 개체를 보냅니다.

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)

매개 변수

obj

Object

큐에 보낼 개체입니다.

transaction

MessageQueueTransaction

MessageQueueTransaction 개체

예외

ArgumentNullException

transaction 매개 변수가 null인 경우

MessageQueueException

Path 속성이 설정되어 있지 않은 경우

또는

메시지 큐 애플리케이션에서 트랜잭션을 잘못 사용했음을 나타냈습니다.

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 트랜잭션 큐에 문자열을 보낸 다음 해당 큐에서 메시지를 받습니다.

#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

설명

이 오버로드를 사용하여 매개 변수로 정의된 내부 트랜잭션 컨텍스트를 사용하여 에서 참조하는 트랜잭션 큐에 MessageQueue매개 변수가 transaction 포함된 obj 메시지를 보냅니다. 큐에 보내는 개체는 또는 관리되는 Message 개체일 수 있습니다. 이외의 개체를 Message보내면 개체가 직렬화되어 메시지 본문에 삽입됩니다.

이 오버로드를 사용하여 비 트랜잭션 큐에 메시지를 보내는 경우 예외를 throw하지 않고 배달 못한 편지 큐로 메시지를 보낼 수 있습니다.

를 호출Send(Object)하기 전에 속성을 설정 Formatter 하지 않으면 포맷터는 기본적으로 로 설정XmlMessageFormatter됩니다.

속성은 DefaultPropertiesToSend 이외의 개체 Message에 적용됩니다. 를 지정 하면 예를 들어, 레이블 또는 사용 하 여 우선 순위를 DefaultPropertiesToSend 멤버를이 값은 형식이 아닌 개체를 포함 하는 모든 메시지에 적용 Message 경우 애플리케이션 큐로 보냅니다는 합니다. 를 보낼 Message때 에 대해 Message 설정된 속성 값이 우선 DefaultPropertiesToSend 적으로 적용되고 메시지의 Message.Formatter 속성이 큐의 MessageQueue.Formatter 속성보다 우선합니다.

MessageQueueTransaction 스레딩 아파트를 인식 하며 따라서 아파트 상태가 STA, 트랜잭션이 여러 스레드를 사용할 수 없습니다. 에 주 스레드의 상태를 설정 하는 Visual Basic STA이므로 적용 해야 합니다는 MTAThreadAttribute 에 Main 서브루틴입니다. 그렇지 않으면 다른 스레드를 사용하여 트랜잭션 메시지를 전달할 때 MessageQueueException 예외가 throw됩니다. 적용 된 MTAThreadAttribute 다음 조각을 사용 하 여 합니다.

<System.MTAThreadAttribute>
 public sub Main()

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

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

Send(Object, MessageQueueTransactionType)

이 MessageQueue가 참조하는 큐에 개체를 보냅니다.

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)

매개 변수

obj

Object

큐에 보낼 개체입니다.

transactionType

MessageQueueTransactionType

MessageQueueTransactionType 값 중 하나로, 메시지와 연결할 트랜잭션 컨텍스트 형식을 설명합니다.

예외

InvalidEnumArgumentException

transactionType 매개 변수가 MessageQueueTransactionType 멤버 중 하나가 아닌 경우

MessageQueueException

Path 속성이 설정되어 있지 않은 경우

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 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);

설명

이 오버로드를 사용하여 매개 변수로 정의된 트랜잭션 컨텍스트를 사용하여 에서 참조하는 큐에 MessageQueue매개 변수가 transactionType 포함된 obj 메시지를 보냅니다. transactionType 메시지를 보내는 데 사용할 스레드에 연결된 외부 트랜잭션 컨텍스트가 이미 있는 경우 매개 변수에 를 지정 Automatic 합니다. Single 메시지를 단일 내부 트랜잭션으로 보낼지 지정합니다. 트랜잭션 메시지를 비 트랜잭션 스레드로 보낼지 지정할 수 있습니다 None .

큐에 보내는 개체는 또는 관리되는 Message 개체일 수 있습니다. 이외의 개체를 Message보내면 개체가 직렬화되어 메시지 본문에 삽입됩니다.

를 호출Send(Object)하기 전에 속성을 설정 Formatter 하지 않으면 포맷터는 기본적으로 로 설정XmlMessageFormatter됩니다.

속성은 DefaultPropertiesToSend 이외의 개체 Message에 적용됩니다. 를 지정 하면 예를 들어, 레이블 또는 사용 하 여 우선 순위를 DefaultPropertiesToSend 멤버를이 값은 형식이 아닌 개체를 포함 하는 모든 메시지에 적용 Message 경우 애플리케이션 큐로 보냅니다는 합니다. 를 보낼 Message때 에 대해 Message 설정된 속성 값이 우선 DefaultPropertiesToSend 적으로 적용되고 메시지의 Message.Formatter 속성이 큐의 MessageQueue.Formatter 속성보다 우선합니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

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

Send(Object, String)

이 MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.

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)

매개 변수

obj

Object

큐에 보낼 개체입니다.

label

String

메시지의 레이블입니다.

예외

ArgumentNullException

label 매개 변수가 null인 경우

MessageQueueException

Path 속성이 설정되어 있지 않은 경우

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 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");

설명

이 오버로드를 사용하여 매개 변수가 포함된 obj 메시지를 에서 참조하는 큐로 보냅니다 MessageQueue. 이 오버로드를 사용하면 메시지를 식별하는 문자열 레이블을 지정할 수 있습니다. 큐에 보내는 개체는 , 구조체, 데이터 개체 또는 관리되는 개체일 Message수 있습니다. 이외의 개체를 Message보내면 개체가 직렬화되어 메시지 본문에 삽입됩니다.

메시지 레이블에 메시지 큐 레이블을 다릅니다 되지만 둘 다 애플리케이션 종속 되어 상속 메시지 큐에 의미가 없습니다.

이 오버로드를 사용하여 트랜잭션 큐에 메시지를 보내는 경우 메시지는 배달 못 한 편지 큐로 전송됩니다. 메시지가 다른 메시지를 포함하는 트랜잭션의 일부가 되도록 하려면 또는 MessageQueueTransactionType 를 매개 변수로 사용하는 MessageQueueTransaction 오버로드를 사용합니다.

메시지를 Path 보내기 전에 이 MessageQueue instance 속성을 지정해야 합니다. 를 호출Send(Object)하기 전에 속성을 설정 Formatter 하지 않으면 포맷터는 기본적으로 로 설정XmlMessageFormatter됩니다.

속성은 DefaultPropertiesToSend 이외의 개체 Message에 적용됩니다. 를 지정 하면 예를 들어, 레이블 또는 사용 하 여 우선 순위를 DefaultPropertiesToSend 멤버를이 값은 형식이 아닌 개체를 포함 하는 모든 메시지에 적용 Message 경우 애플리케이션 큐로 보냅니다는 합니다. 를 보낼 Message때 에 대해 Message 설정된 속성 값이 우선 DefaultPropertiesToSend 적으로 적용되고 메시지의 Message.Formatter 속성이 큐의 MessageQueue.Formatter 속성보다 우선합니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

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

Send(Object, String, MessageQueueTransaction)

이 MessageQueue가 참조하는 트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.

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)

매개 변수

obj

Object

큐에 보낼 개체입니다.

label

String

메시지의 레이블입니다.

transaction

MessageQueueTransaction

MessageQueueTransaction 개체

예외

ArgumentNullException

label 매개 변수가 null인 경우

또는

transaction 매개 변수가 null인 경우

MessageQueueException

Path 속성이 설정되어 있지 않은 경우

또는

메시지 큐 애플리케이션에서 트랜잭션을 잘못 사용했음을 나타냈습니다.

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 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();
}

설명

이 오버로드를 사용하여 매개 변수로 정의된 내부 트랜잭션 컨텍스트를 사용하여 에서 참조하는 트랜잭션 큐에 MessageQueue매개 변수가 transaction 포함된 obj 메시지를 보냅니다. 이 오버로드를 사용하면 메시지를 식별하는 문자열 레이블을 지정할 수 있습니다. 큐에 보내는 개체는 , 구조체, 데이터 개체 또는 관리되는 개체일 Message수 있습니다. 이외의 개체를 Message보내면 개체가 직렬화되어 메시지 본문에 삽입됩니다.

메시지 레이블에 메시지 큐 레이블을 다릅니다 되지만 둘 다 애플리케이션 종속 되어 상속 메시지 큐에 의미가 없습니다.

이 오버로드를 사용하여 비 트랜잭션 큐에 메시지를 보내는 경우 예외를 throw하지 않고 배달 못한 편지 큐로 메시지를 보낼 수 있습니다.

를 호출Send(Object)하기 전에 속성을 설정 Formatter 하지 않으면 포맷터는 기본적으로 로 설정XmlMessageFormatter됩니다.

속성은 DefaultPropertiesToSend 이외의 개체 Message에 적용됩니다. 를 지정 하면 예를 들어, 레이블 또는 사용 하 여 우선 순위를 DefaultPropertiesToSend 멤버를이 값은 형식이 아닌 개체를 포함 하는 모든 메시지에 적용 Message 경우 애플리케이션 큐로 보냅니다는 합니다. 를 Message보낼 때 에 대해 Message 설정된 속성 값이 우선 DefaultPropertiesToSend 적으로 적용되고 메시지의 Message.Formatter 속성이 큐의 MessageQueue.Formatter 속성보다 우선합니다.

MessageQueueTransaction 스레딩 아파트를 인식 하며 따라서 아파트 상태가 STA, 트랜잭션이 여러 스레드를 사용할 수 없습니다. 에 주 스레드의 상태를 설정 하는 Visual Basic STA이므로 적용 해야 합니다는 MTAThreadAttribute 에 Main 서브루틴입니다. 그렇지 않으면 다른 스레드를 사용하여 트랜잭션 메시지를 전달할 때 MessageQueueException 예외가 throw됩니다. 적용 된 MTAThreadAttribute 다음 조각을 사용 하 여 합니다.

<System.MTAThreadAttribute>
 public sub Main()

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

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

Send(Object, String, MessageQueueTransactionType)

이 MessageQueue가 참조하는 큐에 개체를 보내고 메시지에 레이블을 지정합니다.

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)

매개 변수

obj

Object

큐에 보낼 개체입니다.

label

String

메시지의 레이블입니다.

transactionType

MessageQueueTransactionType

MessageQueueTransactionType 값 중 하나로, 메시지와 연결할 트랜잭션 컨텍스트 형식을 설명합니다.

예외

ArgumentNullException

label 매개 변수가 null인 경우

MessageQueueTransaction

메시지 큐 애플리케이션에서 트랜잭션을 잘못 사용했음을 나타냈습니다.

InvalidEnumArgumentException

transactionType 매개 변수가 MessageQueueTransactionType 멤버 중 하나가 아닌 경우

MessageQueueException

Path 속성이 설정되어 있지 않은 경우

또는

메시지 큐 메서드에 액세스하는 동안 오류가 발생한 경우

예제

다음 코드 예제에서는 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);

설명

이 오버로드를 사용하여 매개 변수로 정의된 트랜잭션 컨텍스트를 사용하여 에서 참조하는 큐에 MessageQueue매개 변수가 transactionType 포함된 obj 메시지를 보냅니다. transactionType 메시지를 보내는 데 사용할 스레드에 연결된 외부 트랜잭션 컨텍스트가 이미 있는 경우 매개 변수에 를 지정 Automatic 합니다. Single 메시지를 단일 내부 트랜잭션으로 보낼지 지정합니다. 트랜잭션 메시지를 비 트랜잭션 스레드로 보낼지 지정할 수 있습니다 None .

큐에 보내는 개체는 또는 관리되는 Message 개체일 수 있습니다. 이외의 개체를 Message보내면 개체가 직렬화되어 메시지 본문에 삽입됩니다. 이 오버로드를 사용하면 메시지를 식별하는 문자열 레이블을 지정할 수 있습니다.

메시지 레이블에 메시지 큐 레이블을 다릅니다 되지만 둘 다 애플리케이션 종속 되어 상속 메시지 큐에 의미가 없습니다.

를 호출Send(Object)하기 전에 속성을 설정 Formatter 하지 않으면 포맷터는 기본적으로 로 설정XmlMessageFormatter됩니다.

속성은 DefaultPropertiesToSend 이외의 개체 Message에 적용됩니다. 를 지정 하면 예를 들어, 레이블 또는 사용 하 여 우선 순위를 DefaultPropertiesToSend 멤버를이 값은 형식이 아닌 개체를 포함 하는 모든 메시지에 적용 Message 경우 애플리케이션 큐로 보냅니다는 합니다. 를 보낼 Message때 에 대해 Message 설정된 속성 값이 보다 우선 DefaultPropertiesToSend적으로 적용되고 메시지의 Message.Formatter 속성이 큐의 MessageQueue.Formatter 속성보다 우선합니다.

다음 표에서는 이 메서드를 다양한 작업 그룹 모드에서 사용할 수 있는지 여부를 보여 줍니다.

작업 그룹 모드	사용 가능
수집	Yes
로컬 컴퓨터 및 직접 형식 이름	Yes
원격 컴퓨터	No
원격 컴퓨터 및 직접 형식 이름	Yes

추가 정보

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