MessageQueue.Create Metodo
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Crea una nuova coda nel percorso specificato su un server di Accodamento messaggi.
Create(String) |
Crea una coda non transazionale di Accodamento messaggi nel percorso specificato. |
Create(String, Boolean) |
Crea una coda transazionale o non transazionale di Accodamento messaggi nel percorso specificato. |
Crea una coda non transazionale di Accodamento messaggi nel percorso specificato.
public:
static System::Messaging::MessageQueue ^ Create(System::String ^ path);
public static System.Messaging.MessageQueue Create (string path);
static member Create : string -> System.Messaging.MessageQueue
Public Shared Function Create (path As String) As MessageQueue
Parametri
- path
- String
Percorso della coda da creare.
Restituisce
Oggetto MessageQueue che rappresenta la nuova coda.
Eccezioni
Il parametro path
è null
o è una stringa vuota ("").
La coda è già presente nel percorso specificato.
-oppure-
Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.
Esempio
Nell'esempio di codice seguente vengono create code pubbliche e private. Invia un messaggio alle code selezionate.
#using <system.dll>
#using <system.messaging.dll>
using namespace System;
using namespace System::Messaging;
// This example creates new public and private queues.
ref class MyNewQueue
{
public:
void CreatePublicQueues()
{
// Create and connect to a public Message Queuing queue.
if ( !MessageQueue::Exists( ".\\newPublicQueue" ) )
{
// Create the queue if it does not exist.
MessageQueue^ myNewPublicQueue = MessageQueue::Create( ".\\newPublicQueue" );
// Send a message to the queue.
myNewPublicQueue->Send( "My message data." );
}
// Create (but do not connect to) a second public queue.
if ( !MessageQueue::Exists( ".\\newPublicResponseQueue" ) )
{
MessageQueue::Create( ".\\newPublicResponseQueue" );
}
return;
}
// Creates private queues and sends a message.
void CreatePrivateQueues()
{
// Create and connect to a private Message Queuing queue.
if ( !MessageQueue::Exists( ".\\Private$\\newPrivQueue" ) )
{
// Create the queue if it does not exist.
MessageQueue^ myNewPrivateQueue = MessageQueue::Create( ".\\Private$\\newPrivQueue" );
// Send a message to the queue.
myNewPrivateQueue->Send( "My message data." );
}
// Create (but do not connect to) a second private queue.
if ( !MessageQueue::Exists( ".\\Private$\\newResponseQueue" ) )
{
MessageQueue::Create( ".\\Private$\\newResponseQueue" );
}
return;
}
};
// Provides an entry point into the application.
int main()
{
// Create a new instance of the class.
MyNewQueue^ myNewQueue = gcnew MyNewQueue;
// Create public and private queues.
myNewQueue->CreatePublicQueues();
myNewQueue->CreatePrivateQueues();
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 creates new public and private
// queues.
//**************************************************
public static void Main()
{
// Create a new instance of the class.
MyNewQueue myNewQueue = new MyNewQueue();
// Create public and private queues.
myNewQueue.CreatePublicQueues();
myNewQueue.CreatePrivateQueues();
return;
}
//**************************************************
// Creates public queues and sends a message.
//**************************************************
public void CreatePublicQueues()
{
// Create and connect to a public Message Queuing queue.
if (!MessageQueue.Exists(".\\newPublicQueue"))
{
// Create the queue if it does not exist.
MessageQueue myNewPublicQueue =
MessageQueue.Create(".\\newPublicQueue");
// Send a message to the queue.
myNewPublicQueue.Send("My message data.");
}
// Create (but do not connect to) a second public queue.
if (!MessageQueue.Exists(".\\newPublicResponseQueue"))
{
MessageQueue.Create(".\\newPublicResponseQueue");
}
return;
}
//**************************************************
// Creates private queues and sends a message.
//**************************************************
public void CreatePrivateQueues()
{
// Create and connect to a private Message Queuing queue.
if (!MessageQueue.Exists(".\\Private$\\newPrivQueue"))
{
// Create the queue if it does not exist.
MessageQueue myNewPrivateQueue =
MessageQueue.Create(".\\Private$\\newPrivQueue");
// Send a message to the queue.
myNewPrivateQueue.Send("My message data.");
}
// Create (but do not connect to) a second private queue.
if (!MessageQueue.Exists(".\\Private$\\newResponseQueue"))
{
MessageQueue.Create(".\\Private$\\newResponseQueue");
}
return;
}
}
}
Imports System.Messaging
' Provides a container class for the example.
Public Class MyNewQueue
' Provides an entry point into the application.
'
' This example creates new public and private
' queues.
Public Shared Sub Main()
' Create a new instance of the class.
Dim myNewQueue As New MyNewQueue()
' Create public and private queues.
myNewQueue.CreatePublicQueues()
myNewQueue.CreatePrivateQueues()
Return
End Sub
' Creates public queues and sends a message.
Public Sub CreatePublicQueues()
' Create and connect to a public Message Queuing queue.
If Not MessageQueue.Exists(".\newPublicQueue") Then
' Create the queue if it does not exist.
Dim myNewPublicQueue As MessageQueue = _
MessageQueue.Create(".\newPublicQueue")
' Send a message to the queue.
myNewPublicQueue.Send("My message data.")
End If
' Create (but do not connect to) a second public queue.
If Not MessageQueue.Exists(".\newPublicResponseQueue") _
Then
MessageQueue.Create(".\newPublicResponseQueue")
End If
Return
End Sub
' Creates private queues and sends a message.
Public Sub CreatePrivateQueues()
' Create and connect to a private Message Queuing queue.
If Not MessageQueue.Exists(".\Private$\newPrivateQueue") _
Then
' Create the queue if it does not exist.
Dim myNewPrivateQueue As MessageQueue = _
MessageQueue.Create(".\Private$\newPrivateQueue")
' Send a message to the queue.
myNewPrivateQueue.Send("My message data.")
End If
' Create (but do not connect to) a second private queue.
If Not MessageQueue.Exists(".\Private$\newResponseQueue") _
Then
MessageQueue.Create(".\Private$\newResponseQueue")
End If
Return
End Sub
End Class
Commenti
Usare questo overload per creare una coda di accodamento messaggi non transazionali.
Per creare una nuova istanza della MessageQueue classe nell'applicazione e associarla a una coda esistente, usare il MessageQueue costruttore. Per creare una nuova coda in Accodamento messaggi, chiamare Create(String).
La sintassi per il path
parametro dipende dal tipo di riferimento della coda, come illustrato nella tabella seguente.
Tipo di coda | Sintassi |
---|---|
Coda pubblica | MachineName \QueueName |
Coda privata | MachineName \Private$ \QueueName |
Usare "." per il computer locale. Per altre sintassi, vedere la Path proprietà .
La tabella seguente mostra se questo metodo è disponibile in varie modalità gruppo di lavoro.
Modalità gruppo di lavoro | Disponibile |
---|---|
Computer locale | Sì |
Nome del computer locale e del formato diretto | Sì |
Computer remoto | No |
Nome del formato diretto e del computer remoto | No |
Vedi anche
Si applica a
.NET Framework 4.8.1 e altre versioni
Prodotto | Versioni |
---|---|
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
Crea una coda transazionale o non transazionale di Accodamento messaggi nel percorso specificato.
public:
static System::Messaging::MessageQueue ^ Create(System::String ^ path, bool transactional);
public static System.Messaging.MessageQueue Create (string path, bool transactional);
static member Create : string * bool -> System.Messaging.MessageQueue
Public Shared Function Create (path As String, transactional As Boolean) As MessageQueue
Parametri
- path
- String
Percorso della coda da creare.
- transactional
- Boolean
true
per creare una coda transazionale; false
per creare una coda non transazionale.
Restituisce
Oggetto MessageQueue che rappresenta la nuova coda.
Eccezioni
Il parametro path
è null
o è una stringa vuota ("").
La coda è già presente nel percorso specificato.
-oppure-
Si è verificato un errore durante l'accesso a un metodo di Accodamento messaggi.
Esempio
Nell'esempio di codice seguente vengono create code transazionali pubbliche e private. Invia un messaggio alle code selezionate.
#using <system.dll>
#using <system.messaging.dll>
using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:
// Creates public transactional queues and sends a
// message.
void CreatePublicTransactionalQueues()
{
// Create and connect to a public message Queuing queue.
if ( !MessageQueue::Exists( ".\\newPublicTransQueue1" ) )
{
// Create the queue if it does not exist.
MessageQueue::Create( ".\\newPublicTransQueue1", true );
}
// Connect to the queue.
MessageQueue^ myNewPublicQueue = gcnew MessageQueue( ".\\newPublicTransQueue1" );
// Create a transaction.
MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
// Begin the transaction.
myTransaction->Begin();
// Send the message.
myNewPublicQueue->Send( "My Message Data.", myTransaction );
// Commit the transaction.
myTransaction->Commit();
if ( !MessageQueue::Exists( ".\\newPublicTransQueue2" ) )
{
// Create (but do not connect to) second public queue
MessageQueue::Create( ".\\newPublicTransQueue2", true );
}
return;
}
// Creates private queues and sends a message.
void CreatePrivateTransactionalQueues()
{
// Create and connect to a private Message Queuing queue.
if ( !MessageQueue::Exists( ".\\Private$\\newPrivTransQ1" ) )
{
// Create the queue if it does not exist.
MessageQueue^ myNewPrivateQueue = MessageQueue::Create( ".\\Private$\\newPrivTransQ1", true );
}
// Connect to the queue.
MessageQueue^ myNewPrivateQueue = gcnew MessageQueue( ".\\Private$\\newPrivTransQ1" );
// Create a transaction.
MessageQueueTransaction^ myTransaction = gcnew MessageQueueTransaction;
// Begin the transaction.
myTransaction->Begin();
// Send the message.
myNewPrivateQueue->Send( "My Message Data.", myTransaction );
// Commit the transaction.
myTransaction->Commit();
// Create (but do not connect to) a second private queue.
if ( !MessageQueue::Exists( ".\\Private$\\newPrivTransQ2" ) )
{
MessageQueue::Create( ".\\Private$\\newPrivTransQ2", true );
}
return;
}
};
// Provides an entry point into the application.
// This example creates new transactional queues.
int main()
{
// Create a new instance of the class.
MyNewQueue^ myNewQueue = gcnew MyNewQueue;
// Create transactional queues.
myNewQueue->CreatePublicTransactionalQueues();
myNewQueue->CreatePrivateTransactionalQueues();
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 creates new transactional queues.
//**************************************************
public static void Main()
{
// Create a new instance of the class.
MyNewQueue myNewQueue = new MyNewQueue();
// Create transactional queues.
myNewQueue.CreatePublicTransactionalQueues();
myNewQueue.CreatePrivateTransactionalQueues();
return;
}
//**************************************************
// Creates public transactional queues and sends a
// message.
//**************************************************
public void CreatePublicTransactionalQueues()
{
// Create and connect to a public Message Queuing queue.
if (!MessageQueue.Exists(".\\newPublicTransQueue1"))
{
// Create the queue if it does not exist.
MessageQueue.Create(".\\newPublicTransQueue1", true);
}
// Connect to the queue.
MessageQueue myNewPublicQueue =
new MessageQueue(".\\newPublicTransQueue1");
// Send a message to the queue.
// Create a transaction.
MessageQueueTransaction myTransaction = new
MessageQueueTransaction();
// Begin the transaction.
myTransaction.Begin();
// Send the message.
myNewPublicQueue.Send("My Message Data.", myTransaction);
// Commit the transaction.
myTransaction.Commit();
if (!MessageQueue.Exists(".\\newPublicTransQueue2"))
{
// Create (but do not connect to) second public queue.
MessageQueue.Create(".\\newPublicTransQueue2", true);
}
return;
}
//**************************************************
// Creates private queues and sends a message.
//**************************************************
public void CreatePrivateTransactionalQueues()
{
// Create and connect to a private Message Queuing queue.
if (!MessageQueue.Exists(".\\Private$\\newPrivTransQ1"))
{
// Create the queue if it does not exist.
MessageQueue.Create(".\\Private$\\newPrivTransQ1", true);
}
// Connect to the queue.
MessageQueue myNewPrivateQueue =
new MessageQueue(".\\Private$\\newPrivTransQ1");
// Send a message to the queue.
// Create a transaction.
MessageQueueTransaction myTransaction = new
MessageQueueTransaction();
// Begin the transaction.
myTransaction.Begin();
// Send the message.
myNewPrivateQueue.Send("My Message Data.", myTransaction);
// Commit the transaction.
myTransaction.Commit();
// Create (but do not connect to) a second private queue.
if (!MessageQueue.Exists(".\\Private$\\newPrivTransQ2"))
{
MessageQueue.Create(".\\Private$\\newPrivTransQ2",
true);
}
return;
}
}
}
Imports System.Messaging
Public Class MyNewQueue
' Provides an entry point into the application.
'
' This example creates new transactional queues.
Public Shared Sub Main()
' Create a new instance of the class.
Dim myNewQueue As New MyNewQueue
' Create transactional queues.
myNewQueue.CreatePublicTransactionalQueues()
myNewQueue.CreatePrivateTransactionalQueues()
Return
End Sub
' Creates public transactional queues and sends a
' message.
Public Sub CreatePublicTransactionalQueues()
' Create and connect to a public Message Queuing queue.
If Not MessageQueue.Exists(".\newPublicTransQueue1") Then
' Create the queue if it does not exist.
MessageQueue.Create(".\newPublicTransQueue1", True)
End If
' Connect to the queue.
Dim myNewPublicQueue As New MessageQueue(".\newPublicTransQueue1")
' Create a transaction.
Dim myTransaction As New MessageQueueTransaction
' Begin the transaction.
myTransaction.Begin()
' Send the message.
myNewPublicQueue.Send("My Message Data.", myTransaction)
' Commit the transaction.
myTransaction.Commit()
If Not MessageQueue.Exists(".\newPublicTransQueue2") Then
' Create (but do not connect to) a second queue.
MessageQueue.Create(".\newPublicTransQueue2", True)
End If
Return
End Sub
' Creates private queues and sends a message.
Public Sub CreatePrivateTransactionalQueues()
' Create and connect to a private Message Queuing queue.
If Not MessageQueue.Exists(".\Private$\newPrivTransQ1") _
Then
' Create the queue if it does not exist.
MessageQueue.Create(".\Private$\newPrivTransQ1", True)
End If
' Connect to the queue.
Dim myNewPrivateQueue As New MessageQueue(".\Private$\newPrivTransQ1")
' Create a transaction.
Dim myTransaction As New MessageQueueTransaction
' Begin the transaction.
myTransaction.Begin()
' Send the message.
myNewPrivateQueue.Send("My Message Data.", myTransaction)
' Commit the transaction.
myTransaction.Commit()
' Create (but do not connect to) a second private queue.
If Not MessageQueue.Exists(".\Private$\newPrivTransQ2") _
Then
MessageQueue.Create(".\Private$\newPrivTransQ2", True)
End If
Return
End Sub
End Class
Commenti
È possibile usare questo overload per creare una coda transazionale in Accodamento messaggi. È possibile creare una coda non transazionale impostando il transactional
parametro su false
o chiamando l'altro overload di Create(String).
Per creare una nuova istanza della MessageQueue classe nell'applicazione e associarla a una coda esistente, usare il MessageQueue costruttore. Per creare una nuova coda in Accodamento messaggi, chiamare Create(String).
La sintassi per il path
parametro dipende dal tipo di riferimento della coda, come illustrato nella tabella seguente.
Tipo di coda | Sintassi |
---|---|
Coda pubblica | MachineName \QueueName |
Coda privata | MachineName \Private$ \QueueName |
Usare "." per il computer locale. Per altre sintassi, vedere la Path proprietà .
La tabella seguente mostra se questo metodo è disponibile in varie modalità gruppo di lavoro.
Modalità gruppo di lavoro | Disponibile |
---|---|
Computer locale | Sì |
Nome del computer locale e del formato diretto | Sì |
Computer remoto | No |
Nome del formato diretto e del computer remoto | No |
Vedi anche
Si applica a
.NET Framework 4.8.1 e altre versioni
Prodotto | Versioni |
---|---|
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
Feedback su .NET
.NET è un progetto di open source. Selezionare un collegamento per fornire feedback: