Message Message Message Message Class

Definizione

Fornisce accesso alle proprietà necessarie per definire un messaggio di Accodamento messaggi.Provides access to the properties needed to define a Message Queuing message.

public ref class Message : System::ComponentModel::Component
public class Message : System.ComponentModel.Component
type Message = class
    inherit Component
Public Class Message
Inherits Component
Ereditarietà

Esempi

Nell'esempio di codice seguente viene illustrata la formattazione BinaryMessageFormatterdi un corpo del messaggio tramite.The following code example demonstrates formatting a message body using BinaryMessageFormatter.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;

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

   //*************************************************
   // Creates a new queue.
   //*************************************************
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }


   //*************************************************
   // Sends an image to a queue, using the BinaryMessageFormatter.
   //*************************************************
   void SendMessage()
   {
      try
      {
         
         // Create a new bitmap.
         // The file must be in the \bin\debug or \bin\retail folder, or
         // you must give a full path to its location.
         Image^ myImage = Bitmap::FromFile( "SentImage::bmp" );
         
         // Connect to a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
         Message^ myMessage = gcnew Message( myImage,gcnew BinaryMessageFormatter );
         
         // Send the image to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }


   //*************************************************
   // Receives a message containing an image.
   //*************************************************
   void ReceiveMessage()
   {
      try
      {
         
         // Connect to the a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
         
         // Set the formatter to indicate body contains an Order.
         myQueue->Formatter = gcnew BinaryMessageFormatter;
         
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Bitmap^ myImage = static_cast<Bitmap^>(myMessage->Body);
         
         // This will be saved in the \bin\debug or \bin\retail folder.
         myImage->Save( "ReceivedImage::bmp", System::Drawing::Imaging::ImageFormat::Bmp );
      }
      catch ( MessageQueueException^ ) 
      {
         
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }
      catch ( IOException^ e ) 
      {
         
         // Handle file access exceptions.
      }

      
      // Catch other exceptions as necessary.
      return;
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Create a queue on the local computer.
   MyNewQueue::CreateQueue( ".\\myQueue" );
   
   // Send a message to a queue.
   myNewQueue->SendMessage();
   
   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

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 queue.
		//**************************************************

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

			// Create a queue on the local computer.
			CreateQueue(".\\myQueue");
			
			// Send a message to a queue.
			myNewQueue.SendMessage();

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

			return;
		}

		//**************************************************
		// Creates a new queue.
		//**************************************************

		public static void CreateQueue(string queuePath)
		{
			try	
			{
				if(!MessageQueue.Exists(queuePath))
				{
					MessageQueue.Create(queuePath);
				}
				else
				{
					Console.WriteLine(queuePath + " already exists.");
				}
			}
			catch (MessageQueueException e)
			{
				Console.WriteLine(e.Message);
			}
			
		}

		//**************************************************
		// Sends an image to a queue, using the BinaryMessageFormatter.
		//**************************************************
		
		public void SendMessage()
		{
			try{

				// Create a new bitmap.
				// The file must be in the \bin\debug or \bin\retail folder, or
				// you must give a full path to its location.
				Image myImage = Bitmap.FromFile("SentImage.bmp");

				// Connect to a queue on the local computer.
				MessageQueue myQueue = new MessageQueue(".\\myQueue");
				
				Message myMessage = new Message(myImage, new BinaryMessageFormatter());

				// Send the image to the queue.
				myQueue.Send(myMessage);
			}
			catch(ArgumentException e)
			{
				Console.WriteLine(e.Message);
			
			}

			return;
		}


		//**************************************************
		// Receives a message containing an image.
		//**************************************************
		
		public  void ReceiveMessage()
		{
						
			try
			{

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

				// Set the formatter to indicate body contains an Order.
				myQueue.Formatter = new BinaryMessageFormatter();

				// Receive and format the message. 
				System.Messaging.Message myMessage = myQueue.Receive(); 
				Bitmap myImage = (Bitmap)myMessage.Body;
				
				// This will be saved in the \bin\debug or \bin\retail folder.
				myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
				
				
			}
			
			catch (MessageQueueException)
			{
				// Handle Message Queuing exceptions.
			}

			// Handle invalid serialization format.
			catch (InvalidOperationException e)
			{
				Console.WriteLine(e.Message);
			}

			catch (IOException e)
			{
				// Handle file access exceptions.
			}
			
			// Catch other exceptions as necessary.

			return;
		}
	}
}
Imports System
Imports System.Messaging
Imports System.Drawing
Imports System.IO


Namespace MyProj
    _
   
   
   Public Class MyNewQueue
      
      
      '**************************************************
      ' Provides an entry point into the application.
      '		 
      ' This example sends and receives a message from
      ' a queue.
      '**************************************************
      Public Shared Sub Main()
         ' Create a new instance of the class.
         Dim myNewQueue As New MyNewQueue()
         
         ' Create a queue on the local computer.
         CreateQueue(".\myQueue")
         
         ' Send a message to a queue.
         myNewQueue.SendMessage()
         
         ' Receive a message from a queue.
         myNewQueue.ReceiveMessage()
         
         Return
      End Sub 'Main
      
      
      '**************************************************
      ' Creates a new queue.
      '**************************************************
      Public Shared Sub CreateQueue(queuePath As String)
         Try
            If Not MessageQueue.Exists(queuePath) Then
               MessageQueue.Create(queuePath)
            Else
               Console.WriteLine((queuePath + " already exists."))
            End If
         Catch e As MessageQueueException
            Console.WriteLine(e.Message)
         End Try
      End Sub 'CreateQueue
       
      
      '**************************************************
      ' Sends an image to a queue, using the BinaryMessageFormatter.
      '**************************************************
      Public Sub SendMessage()
         Try
            
            ' Create a new bitmap.
            ' The file must be in the \bin\debug or \bin\retail folder, or
            ' you must give a full path to its location.
            Dim myImage As Image = Bitmap.FromFile("SentImage.bmp")
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            Dim myMessage As New Message(myImage, New BinaryMessageFormatter())
            
            ' Send the image to the queue.
            myQueue.Send(myMessage)
         Catch e As ArgumentException
            Console.WriteLine(e.Message)
         End Try 
         
         Return
      End Sub 'SendMessage
      
      
      
      '**************************************************
      ' Receives a message containing an image.
      '**************************************************
      Public Sub ReceiveMessage()
         
         Try
            
            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New BinaryMessageFormatter()
            
            ' Receive and format the message. 
            Dim myMessage As System.Messaging.Message = myQueue.Receive()
            Dim myImage As Bitmap = CType(myMessage.Body, Bitmap)
            
            ' This will be saved in the \bin\debug or \bin\retail folder.
            myImage.Save("ReceivedImage.bmp", System.Drawing.Imaging.ImageFormat.Bmp)
         
         
         
         'Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         
         Catch e As IOException
         End Try
         ' Handle file access exceptions.
         
         ' Catch other exceptions as necessary.
         Return
      End Sub 'ReceiveMessage
   End Class 'MyNewQueue
End Namespace 'MyProj

Nell'esempio di codice seguente viene illustrata la formattazione XmlMessageFormatterdi un corpo del messaggio tramite.The following code example demonstrates formatting a message body using XmlMessageFormatter.

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

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};

ref class MyNewQueue
{
public:
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

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

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

         // Create the new order.
         Message^ myMessage = gcnew Message( sentOrder );

         // Send the order to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }

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

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

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

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

int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Create a queue on the local computer.
   MyNewQueue::CreateQueue( ".\\myQueue" );

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

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}
using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

	// The following example 
	// sends to a queue and receives from a queue.
	public class Order
	{
		public int orderId;
		public DateTime orderTime;
	};	

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

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

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

			// Create a queue on the local computer.
			CreateQueue(".\\myQueue");
			
			// Send a message to a queue.
			myNewQueue.SendMessage();

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

			return;
		}

		//**************************************************
		// Creates a new queue.
		//**************************************************

		public static void CreateQueue(string queuePath)
		{
			try	
			{
				if(!MessageQueue.Exists(queuePath))
				{
					MessageQueue.Create(queuePath);
				}
				else
				{
					Console.WriteLine(queuePath + " already exists.");
				}
			}
			catch (MessageQueueException e)
			{
				Console.WriteLine(e.Message);
			}
			
		}

		//**************************************************
		// Sends an Order to a queue.
		//**************************************************
		
		public void SendMessage()
		{
			try
			{

				// Create a new order and set values.
				Order sentOrder = new Order();
				sentOrder.orderId = 3;
				sentOrder.orderTime = DateTime.Now;

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


				
				// Create the new order.
				Message myMessage = new Message(sentOrder);

				// Send the order to the queue.
				myQueue.Send(myMessage);
			}
			catch(ArgumentException e)
			{
				Console.WriteLine(e.Message);
			
			}

			return;
		}


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

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

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

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

			return;
		}
	}
}
Imports System
Imports System.Messaging
Imports System.Drawing
Imports System.IO



   
' The following example 
' sends to a queue and receives from a queue.
Public Class Order
      Public orderId As Integer
      Public orderTime As DateTime
End Class 'Order

   
  
' Provides a container class for the example.

Public Class MyNewQueue
      
      

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

   Public Shared Sub Main()
      ' Create a new instance of the class.
      Dim myNewQueue As New MyNewQueue()
        
      ' Create a queue on the local computer.
      CreateQueue(".\myQueue")
         
      ' Send a message to a queue.
      myNewQueue.SendMessage()
       
      ' Receive a message from a queue.
      myNewQueue.ReceiveMessage()
         
      Return
   End Sub 'Main
      
      

      ' Creates a new queue.
   Public Shared Sub CreateQueue(queuePath As String)
      Try
         If Not MessageQueue.Exists(queuePath) Then
            MessageQueue.Create(queuePath)
         Else
            Console.WriteLine((queuePath + " already exists."))
         End If
      Catch e As MessageQueueException
         Console.WriteLine(e.Message)
      End Try
   End Sub 'CreateQueue
       
      

      ' Sends an Order to a queue.

   Public Sub SendMessage()
      Try
            
            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            
            
            ' Create the new order.
            Dim myMessage As New Message(sentOrder)
            
            ' Send the order to the queue.
            myQueue.Send(myMessage)
      Catch e As ArgumentException
            Console.WriteLine(e.Message)
      End Try 
         
      Return
   End Sub 'SendMessage
      
      
      
 
      ' Receives a message containing an order.
 
   Public Sub ReceiveMessage()
         ' Connect to the a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         ' Set the formatter to indicate body contains an Order.
         myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(Order)})
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            Dim myOrder As Order = CType(myMessage.Body, Order)
            
            ' Display message information.
            Console.WriteLine(("Order ID: " + myOrder.orderId.ToString()))
            Console.WriteLine(("Sent: " + myOrder.orderTime.ToString()))
         
  
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
   End Sub 'ReceiveMessage
End Class 'MyNewQueue

Commenti

Utilizzare la Message classe per visualizzare o ricevere messaggi da una coda oppure per avere un controllo accurato sulle proprietà del messaggio quando si invia un messaggio a una coda.Use the Message class to peek or receive messages from a queue, or to have fine control over message properties when sending a message to a queue.

MessageQueueUsa la Message classe durante la lettura o la ricezione di messaggi dalle code, perché entrambi i MessageQueue.Peek metodi MessageQueue.Receive e creano una nuova istanza della Message classe e impostano le proprietà dell'istanza.MessageQueue uses the Message class when it peeks or receives messages from queues, because both the MessageQueue.Peek and MessageQueue.Receive methods create a new instance of the Message class and set the instance's properties. Le Message proprietà di sola lettura della classe si applicano al recupero di messaggi da una coda, mentre le proprietà di lettura/scrittura si applicano all'invio e al recupero dei messaggi.The Message class's read-only properties apply to retrieving messages from a queue, while the read/write properties apply to sending and retrieving messages. Quando MessageQueue Visualizza o riceve un messaggio da una coda, la MessageReadPropertyFilter proprietà determina quale delle proprietà del messaggio vengono recuperate.When MessageQueue peeks or receives a message from a queue, its MessageReadPropertyFilter property determines which of the message's properties are retrieved.

Il MessageQueue Send metodo della classe consente di specificare qualsiasi tipo di oggetto per un messaggio inviato a tale coda.The MessageQueue class's Send method allows you to specify any object type for a message being sent to that queue. È possibile utilizzare la MessageQueue DefaultPropertiesToSend proprietà dell'istanza per specificare le impostazioni per i messaggi generici inviati alla coda.You can use the MessageQueue instance's DefaultPropertiesToSend property to specify settings for generic messages sent to the queue. I tipi di impostazioni includono il formattatore, l'etichetta, la crittografia e l'autenticazione.The types of settings include formatter, label, encryption, and authentication. È inoltre possibile specificare i valori per i DefaultPropertiesToSend membri appropriati quando si coordina l'applicazione di messaggistica per rispondere ai messaggi di riconoscimento e di report.You can also specify values for the appropriate DefaultPropertiesToSend members when you coordinate your messaging application to respond to acknowledgment and report messages. L'utilizzo Message di un'istanza di per l'invio di un messaggio alla coda offre la flessibilità necessaria per accedere e modificare molte di queste proprietà, sia per un singolo messaggio che per messaggio per messaggio.Using a Message instance to send a message to the queue gives you the flexibility to access and modify many of these properties - either for a single message or on a message-by-message basis. Messagele proprietà hanno la DefaultPropertiesToSendprecedenza su.Message properties take precedence over DefaultPropertiesToSend.

I dati del messaggio vengono archiviati Body nella proprietà e in un extent minore, ovvero AppSpecific le Extension proprietà e.Message data is stored in the Body property and to a lesser extent, the AppSpecific and Extension properties. Quando i dati dei messaggi vengono crittografati, serializzati o deserializzati, solo il contenuto Body della proprietà è interessato.When message data is encrypted, serialized, or deserialized, only the contents of the Body property are affected.

Il contenuto della Body proprietà viene serializzato quando il messaggio viene inviato, utilizzando la Formatter proprietà specificata.The contents of the Body property are serialized when the message is sent, using the Formatter property you specify. Il contenuto serializzato si trova nella BodyStream proprietà.The serialized contents are found in the BodyStream property. È anche possibile impostare direttamente BodyStream la proprietà, ad esempio per inviare un file come contenuto di dati di un messaggio.You can also set the BodyStream property directly, for example, to send a file as the data content of a message. È possibile modificare le Body proprietà Formatter o in qualsiasi momento prima di inviare il messaggio e i dati verranno serializzati in modo appropriato quando si chiama Send.You can change the Body or Formatter properties at any time before sending the message, and the data will be serialized appropriately when you call Send.

Le proprietà definite dalla MessageQueue.DefaultPropertiesToSend proprietà si applicano solo ai messaggi che non sono di tipo. MessageThe properties defined by the MessageQueue.DefaultPropertiesToSend property apply only to messages that are not of type Message. Se si specifica la DefaultPropertiesToSend proprietà per un MessageQueueoggetto, le proprietà denominate in Message modo identico in un'istanza di inviata a tale coda comportano l'Ignorazione di queste proprietà predefinite.If you specify the DefaultPropertiesToSend property for a MessageQueue, the identically named properties in a Message instance sent to that queue cause these default properties to be ignored.

Per un elenco dei valori iniziali delle proprietà di un'istanza Messagedi, vedere Message il costruttore.For a list of initial property values for an instance of Message, see the Message constructor.

Costruttori

Message() Message() Message() Message()

Inizializza una nuova istanza della classe Message con un corpo vuoto.Initializes a new instance of the Message class with an empty body.

Message(Object) Message(Object) Message(Object) Message(Object)

Inizializza una nuova istanza della classe Message utilizzando XmlMessageFormatter per serializzare l'oggetto specificato nel corpo del messaggio.Initializes a new instance of the Message class, using the XmlMessageFormatter to serialize the specified object into the body of the message.

Message(Object, IMessageFormatter) Message(Object, IMessageFormatter) Message(Object, IMessageFormatter) Message(Object, IMessageFormatter)

Inizializza una nuova istanza della classe Message utilizzando il formattatore specificato per serializzare l'oggetto specificato nel corpo del messaggio.Initializes a new instance of the Message class using the specified formatter to serialize the specified object into the body of the message.

Campi

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

Specifica che non è previsto un timeout.Specifies that no time-out exists.

Proprietà

AcknowledgeType AcknowledgeType AcknowledgeType AcknowledgeType

Ottiene o imposta il tipo di messaggio di acknowledgment da restituire all'applicazione che esegue l'invio.Gets or sets the type of acknowledgment message to be returned to the sending application.

Acknowledgment Acknowledgment Acknowledgment Acknowledgment

Ottiene la classificazione dei messaggi di riconoscimento rappresentati da questo messaggio.Gets the classification of acknowledgment that this message represents.

AdministrationQueue AdministrationQueue AdministrationQueue AdministrationQueue

Ottiene o imposta la coda che riceve i messaggi di riconoscimento generati da Accodamento messaggi.Gets or sets the queue that receives the acknowledgement messages that Message Queuing generates.

AppSpecific AppSpecific AppSpecific AppSpecific

Ottiene o imposta informazioni aggiuntive specifiche di un'applicazione.Gets or sets additional, application-specific information.

ArrivedTime ArrivedTime ArrivedTime ArrivedTime

Ottiene l'ora in cui il messaggio ha raggiunto la coda di destinazione.Gets the time that the message arrived in the destination queue.

AttachSenderId AttachSenderId AttachSenderId AttachSenderId

Ottiene o imposta un valore che indica se l'ID del mittente deve essere allegato al messaggio.Gets or sets a value that indicates whether the sender ID should be attached to the message.

Authenticated Authenticated Authenticated Authenticated

Ottiene un valore che indica se il messaggio è stato autenticato.Gets a value that indicates whether the message was authenticated.

AuthenticationProviderName AuthenticationProviderName AuthenticationProviderName AuthenticationProviderName

Ottiene o imposta il nome del provider di crittografia utilizzato per generare la firma digitale del messaggio.Gets or sets the name of the cryptographic provider used to generate the digital signature of the message.

AuthenticationProviderType AuthenticationProviderType AuthenticationProviderType AuthenticationProviderType

Ottiene o imposta il tipo di provider di crittografia utilizzato per generare la firma digitale del messaggio.Gets or sets the type of cryptographic provider used to generate the digital signature of the message.

Body Body Body Body

Ottiene o imposta il contenuto del messaggio.Gets or sets the content of the message.

BodyStream BodyStream BodyStream BodyStream

Ottiene o imposta le informazioni presenti nel corpo del messaggio.Gets or sets the information in the body of the message.

BodyType BodyType BodyType BodyType

Ottiene o imposta il tipo di dati contenuti nel corpo del messaggio.Gets or sets the type of data that the message body contains.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
ConnectorType ConnectorType ConnectorType ConnectorType

Ottiene o imposta un valore che indica che alcune proprietà del messaggio normalmente impostate da Accodamento messaggi sono state impostate dall'applicazione mittente.Gets or sets a value that indicates that some message properties typically set by Message Queuing were set by the sending application.

Container Container Container Container

Ottiene il IContainer che contiene il Component.Gets the IContainer that contains the Component.

(Inherited from Component)
CorrelationId CorrelationId CorrelationId CorrelationId

Ottiene o imposta l'identificatore del messaggio utilizzato dai messaggi di riconoscimento, di rapporto e di risposta per fare riferimento al messaggio originale.Gets or sets the message identifier used by acknowledgment, report, and response messages to reference the original message.

DesignMode DesignMode DesignMode DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
DestinationQueue DestinationQueue DestinationQueue DestinationQueue

Ottiene la coda di destinazione desiderata per un messaggio.Gets the intended destination queue for a message.

DestinationSymmetricKey DestinationSymmetricKey DestinationSymmetricKey DestinationSymmetricKey

Ottiene o imposta la chiave simmetrica utilizzata per crittografare i messaggi crittografati dall'applicazione o i messaggi inviati alle code esterne.Gets or sets the symmetric key used to encrypt application-encrypted messages or messages sent to foreign queues.

DigitalSignature DigitalSignature DigitalSignature DigitalSignature

Ottiene o imposta la firma digitale utilizzata da Accodamento messaggi per autenticare il messaggio.Gets or sets the digital signature that Message Queuing uses to authenticate the message.

EncryptionAlgorithm EncryptionAlgorithm EncryptionAlgorithm EncryptionAlgorithm

Ottiene o imposta l'algoritmo di crittografia utilizzato per crittografare il corpo di un messaggio privato.Gets or sets the encryption algorithm used to encrypt the body of a private message.

Events Events Events Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
Extension Extension Extension Extension

Ottiene o imposta informazioni aggiuntive definite dall'applicazione, associate al messaggio.Gets or sets additional, application-defined information associated with the message.

Formatter Formatter Formatter Formatter

Ottiene o imposta il formattatore utilizzato per serializzare o deserializzare un oggetto da e nel corpo del messaggio.Gets or sets the formatter used to serialize an object into or deserialize an object from the message body.

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

Ottiene o imposta l'algoritmo hash utilizzato da Accodamento messaggi per autenticare un messaggio o creare una firma digitale per un messaggio.Gets or sets the hashing algorithm that Message Queuing uses when authenticating a message or creating a digital signature for a message.

Id Id Id Id

Ottiene l'identificatore del messaggio.Gets the message's identifier.

IsFirstInTransaction IsFirstInTransaction IsFirstInTransaction IsFirstInTransaction

Ottiene un valore che indica se il messaggio è stato il primo messaggio inviato in una transazione.Gets a value that indicates whether the message was the first message sent in a transaction.

IsLastInTransaction IsLastInTransaction IsLastInTransaction IsLastInTransaction

Ottiene un valore che indica se il messaggio è stato l'ultimo messaggio inviato in una transazione.Gets a value that indicates whether the message was the last message sent in a transaction.

Label Label Label Label

Ottiene o imposta una stringa Unicode definita dall'applicazione che descrive il messaggio.Gets or sets an application-defined Unicode string that describes the message.

LookupId LookupId LookupId LookupId

Introdotto in MSMQ 3.0.Introduced in MSMQ 3.0. Ottiene l'identificatore di ricerca del messaggio.Gets the message's lookup identifier.

MessageType MessageType MessageType MessageType

Ottiene il tipo di messaggio: Normal, Acknowledgment o Report.Gets the message type: Normal, Acknowledgment, or Report.

Priority Priority Priority Priority

Ottiene o imposta la priorità del messaggio, che determina la posizione del messaggio nella coda.Gets or sets the message priority, which determines where in the queue the message is placed.

Recoverable Recoverable Recoverable Recoverable

Ottiene o imposta un valore che indica che il recapito del messaggio è garantito anche nel caso di un malfunzionamento del computer o di un problema di rete.Gets or sets a value that indicates whether the message is guaranteed to be delivered in the event of a computer failure or network problem.

ResponseQueue ResponseQueue ResponseQueue ResponseQueue

Ottiene o imposta la coda che riceve i messaggi di risposta generati dall'applicazione.Gets or sets the queue that receives application-generated response messages.

SecurityContext SecurityContext SecurityContext SecurityContext

Ottiene o imposta il contesto per la sicurezza di un messaggio.Gets or sets the security context for a message.

SenderCertificate SenderCertificate SenderCertificate SenderCertificate

Ottiene o imposta il certificato di sicurezza usato per autenticare i messaggi.Gets or sets the security certificate used to authenticate messages.

SenderId SenderId SenderId SenderId

Ottiene l'identificatore del mittente.Gets the identifier of the sending user.

SenderVersion SenderVersion SenderVersion SenderVersion

Ottiene la versione di Accodamento messaggi utilizzata per inviare il messaggio.Gets the version of Message Queuing used to send the message.

SentTime SentTime SentTime SentTime

Ottiene la data e l'ora sul computer mittente dell'invio del messaggio dal Gestore code di origine.Gets the date and time on the sending computer that the message was sent by the source queue manager.

Site Site Site Site

Ottiene o imposta l'oggetto ISite di Component.Gets or sets the ISite of the Component.

(Inherited from Component)
SourceMachine SourceMachine SourceMachine SourceMachine

Ottiene informazioni sul computer in cui il messaggio ha avuto origine.Gets the computer from which the message originated.

TimeToBeReceived TimeToBeReceived TimeToBeReceived TimeToBeReceived

Ottiene o imposta il limite di tempo massimo per la ricezione del messaggio dalla coda di destinazione.Gets or sets the maximum amount of time for the message to be received from the destination queue.

TimeToReachQueue TimeToReachQueue TimeToReachQueue TimeToReachQueue

Ottiene o imposta il limite di tempo massimo impiegato dal messaggio per raggiungere la coda.Gets or sets the maximum amount of time for the message to reach the queue.

TransactionId TransactionId TransactionId TransactionId

Ottiene l'identificatore per la transazione di cui fa parte il messaggio.Gets the identifier for the transaction of which the message was a part.

TransactionStatusQueue TransactionStatusQueue TransactionStatusQueue TransactionStatusQueue

Ottiene la coda di stato della transazione sul computer di origine.Gets the transaction status queue on the source computer.

UseAuthentication UseAuthentication UseAuthentication UseAuthentication

Ottiene o imposta un valore che indica se il messaggio è stato autenticato o deve esserlo prima del suo invio.Gets or sets a value that indicates whether the message was (or must be) authenticated before being sent.

UseDeadLetterQueue UseDeadLetterQueue UseDeadLetterQueue UseDeadLetterQueue

Ottiene o imposta un valore che indica se una copia del messaggio non recapitato deve essere inviata a una coda dei messaggi non recapitabili.Gets or sets a value that indicates whether a copy of the message that could not be delivered should be sent to a dead-letter queue.

UseEncryption UseEncryption UseEncryption UseEncryption

Ottiene o imposta un valore che indica se rendere privato il messaggio.Gets or sets a value that indicates whether to make the message private.

UseJournalQueue UseJournalQueue UseJournalQueue UseJournalQueue

Ottiene o imposta un valore che indica se è necessario inserire una copia del messaggio nel journal del computer di origine.Gets or sets a value that indicates whether a copy of the message should be kept in a machine journal on the originating computer.

UseTracing UseTracing UseTracing UseTracing

Ottiene o imposta un valore che indica se tenere traccia di un messaggio mentre procede verso la coda di destinazione.Gets or sets a value that indicates whether to trace a message as it moves toward its destination queue.

Metodi

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Rilascia tutte le risorse usate da Component.Releases all resources used by the Component.

(Inherited from Component)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Inherited from Component)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ToString() ToString() ToString() ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component.Returns a String containing the name of the Component, if any. Questo metodo non deve essere sottoposto a override.This method should not be overridden.

(Inherited from Component)

Eventi

Disposed Disposed Disposed Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)

Si applica a

Vedi anche