Search Results

Share Query
Link:
Complete Query:
Preferences
Link Opening Settings
Results Filtering Expressions
Create
?
Relevance

    TIBCO eFTL C# Quick Start

    Contents

    Getting Started

    This quick start guide provides basic instructions for writing TIBCO eFTL applications in C# for TIBCO Cloud Messaging.

    Building and running samples

    Follow the steps below to build and run the C# samples:

    • Unzip eftl-dotnet-samples.zip
    • Copy a tcm-config.yaml configuration file into the current working directory.
    • Run sample: dotnet run --project eftl-dotnet-samples/eftlconsumer
    • Run sample: dotnet run --project eftl-dotnet-samples/eftlproducer

    Description of sample applications

    Producer

    The producer demonstrates connecting an eFTL C# application to Cloud Messaging and publishing eFTL messages.

    Consumer

    The consumer demonstrates connecting an eFTL C# application to Cloud Messaging, creating a subscription, and receiving eFTL messages.

    Run the consumer and producer at the same time to demonstrate real-time messaging. Stop the consumer, run the producer, and restart the consumer to demonstrate persistence.

    Using the eFTL SDK

    For C# programs, include the eFTL client C# library: using TIBCO.EFTL;

    Connecting to TIBCO Cloud Messaging

    The client configuration file contains all the information client applications need to securely connect to TIBCO Cloud Messaging. Generate the client configuration file using the roles REST API or user interface. Generate as many configuration files as needed for each Role.

    Note: TIBCO Cloud Messaging samples require a client configuration file to run.

    Client Identifiers

    You must provide a unique identifier for your client if you want it to receive any messages missed while disconnected. Only one application can connect with a given client id at any given time. If a second application connects with a client id already in use by another application, the first application will disconnect.

    Connection Example

    Hashtable props = new Hashtable();
    
    // Set the password to tcm_authentication_key
    props.Add(EFTL.PROPERTY_PASSWORD, "<tcm_authentication_key>");
    
    // Provide a unique client identifier
    props.Add(EFTL.PROPERTY_CLIENT_ID, "abc123");
    
    // Connect to TIBCO Cloud Messaging using the eftl_url
    EFTL.connect("<eftl_url>",
                 props,
                 new ConnectionListener());
    
    class ConnectionListener : IConnectionListener {
       public void OnConnect(IConnection connection){
          Console.WriteLine("connected");
       }
       public void OnDisconnect(IConnection connection, int code, String reason) {
          Console.WriteLine("disconnected: {0}", reason);
       }
       public void OnReconnect(IConnection connection) {
          Console.WriteLine("reconnected\n");
       }
       public void OnError(IConnection connection, int code, String reason) {
          Console.WriteLine("error: {0}", reason);
       }
    });
    

    OnConnect callback

    The onConnect callback is invoked after the connection to TIBCO Cloud Messaging is established. The Connection object passed to the onConnect callback can be used for subscribing to messages and publishing messages.

    OnDisconnect callback

    If the connection cannot be established, or is lost, the onDisconnect callback is invoked.

    OnReconnect callback

    The onReconnect callback is invoked when the client successfully reconnects to TIBCO Cloud Messaging.

    OnError callback

    The onError callback is invoked when TIBCO Cloud Messaging sends an error to the client.

    Publishing Messages

    After the clients are connected to TIBCO Cloud Messaging, they can publish messages. To publish messages, use the connection returned in the onConnect callback.

    // Create a message
    // Fields and arrays of type string, numeric, date, and sub-messages are used in messages.
    IMessage message = connection.CreateMessage();
    message.SetString("event", "hello");
    message.SetString("text": "Hello, World!");
    
    // Publish a message to TIBCO Cloud Messaging
    connection.Publish(message, null);
    
    // Publish a message to TIBCO Cloud Messaging
    connection.publish(message, new CompletionListener());
    
    // To be notified if the publish was successful or if an error occurred, callbacks can be provided.
    Class
    CompletionListener : ICompletionListener {
       public void OnCompletion(IMessage message) {
         Console.WriteLine("publish success\n");
       }
       public void OnError(IMessage message, int code, String reason) {
          Console.WriteLine("publish error: {0}", reason);
       }
    });
    

    Receiving Messages

    After the clients are connected to TIBCO Cloud Messaging, they can create one or more subscriptions to receive messages of interest. You can subscribe to messages by matching the message fields of interest. Use the connection returned in the onConnect callback to register subscriptions.

    // Create a subscription in TIBCO Cloud Messaging
    //
    // This subscription matches all published messages that contain a
    // field named `event` with a value of `hello`
    //
    // This subscription also sets the durable name to "hello" which allows
    // the client to receive messages that were published while disconnected
    //
    connection.subscribe("{\"event\":\"hello\"}", "hello", new SubscriptionListener());
    
    Class SubscriptionListener : ISubscriptionListener {
       public void OnMessage(IMessage[] messages){
          Console.WriteLine("message received: {0}", message.GetString("text"));
       }
       public void OnSubscribe(String subscription) {
          Console.WriteLine("subscribed");
       }
       public void OnError(String subscription, int code, String reason) {
          Console.WriteLine("subscription error: {0}", reason);
       }
    });
    

    Matcher field

    The matcher field specifies the messages that are to be received by matching their content. In this case, the subscription receives all published messages containing a field named event whose value is hello.

    Durable field

    The durable field is the unique subscription name used by TIBCO Cloud Messaging to store messages for the client when the client is not connected.

    onMessage callback

    The onMessage callback is invoked when the content of a published message matches the subscription’s matcher.

    onError callback

    The onError callback is invoked when an error occurs while registering the subscription, typically because of an invalid matcher or invalid durable.