Publication examples

How to publish a topic and work with Publishers and DataWriters.

How to publish a topic and work with Publishers and DataWriters.

Sections:

• Writing data and instances
• Configuring a Publisher
• Looking up a previously created Entity
• Looking up a matched subscription

See also Entity examples for examples that affect all DDS Entities, including Publishers and DataWriters.

Writing data and instances

Example: create a DataWriter using default QoS and publish a data sample

    // Create a DomainParticipant on domain 0
    var factory = Rti.Dds.Domain.DomainParticipantFactory.Instance;
    using Rti.Dds.Domain.DomainParticipant participant =
        factory.CreateParticipant(domainId: 0);
 
    // Create a topic  called "Square" for the type Shape
    Rti.Dds.Topics.Topic<Shape> topic =
        participant.CreateTopic<Shape>("Square");
 
    // In many cases there is no need to explicitly create a Publisher;
    // the ImplicitPublisher can be used to create the DataWriter.
    Rti.Dds.Publication.DataWriter<Shape> writer =
        participant.ImplicitPublisher.CreateDataWriter(topic);
 
    // Create a data sample
    var shape = new Shape
    {
        color = "GREEN",
        shapesize = 50,
        x = 0,
        y = 20
    };
 
    writer.Write(shape);

The IDL definition of the Shape type used in the example is the following:

module Example {
    struct Shape {
        @key string<128> color;
        int32 x;
        int32 y;
        int32 shapesize;
    };
};

For more information about IDL types, see IDL examples.

Example: registering and disposing an instance

 
    // When writing the same instance multiple times, register it first
    // and then pass the instance handle to Write. This makes the operation
    // more efficient.
    var greenHandle = writer.RegisterInstance(new Shape { color = "GREEN" });
 
    var shape = new Shape
    {
        color = "GREEN",
        shapesize = 50,
        x = 0,
        y = 20
    };
 
    for (int i = 0; i < 100; i++)
    {
        shape.x = i;
 
        writer.Write(shape, greenHandle);
    }
 
    // To indicate that the instance is no longer part of the system,
    // call DisposeInstance. A status update will be received as part of
    // sample.Info.State.Instance on the reader side.
    writer.DisposeInstance(greenHandle);
 

Example: writing data with additional parameters

 
    var greenHandle = writer.RegisterInstance(new Shape { color = "GREEN" });
 
    var shape = new Shape
    {
        color = "GREEN",
        shapesize = 50,
        x = 0,
        y = 20
    };
 
    // Write a sample with additional parameters:
    writer.Write(shape, new WriteParams
    {
        // Set the instance handle to make the write operation faster
        InstanceHandle = greenHandle,
 
        // Set an arbitrary timestamp. The reader will see it in
        // sample.Info.SourceTimestamp.
        SourceTimestamp = Time.FromSeconds(1),
 
        // Send an arbitrary integer flag. The reader will see it in
        // sample.Info.Flag. This can be used to attach some meta-data to
        // each sample without changing the type definition.
        Flag = 1234
 
        // ...
    });
 

These examples from the rticonnextdds-examples GitHub repository show other advanced ways to write data:

• Asynchronous Publication
• Custom Flow Controller
• Multichannel

Instance management is discussed in the Keys and Instances section of the Getting Started Guide, which explains how to use the following methods:

• Rti.Dds.Publication.DataWriter.DisposeInstance()
• Rti.Dds.Publication.DataWriter.LookupInstance()
• Rti.Dds.Publication.DataWriter.GetKeyValue()
• Rti.Dds.Publication.DataWriter.UnregisterInstance()

Configuring a Publisher

Example: create a publisher with a Partition QoS

 
    // Create a explicit Publisher with a Partition QoS
    var publisherQos = participant.DefaultPublisherQos
        .WithPartition(p => p.Add("A"));
    Publisher publisher = participant.CreatePublisher(publisherQos);
 
    // All the DataWriters created from this Publisher will communicate
    // only with DataReaders in a matching partition.
    var writer1 = publisher.CreateDataWriter(topic1);
    var writer2 = publisher.CreateDataWriter(topic2);
 

These examples from the rticonnextdds-examples GitHub repository demonstrate uses cases that involve a Publisher:

• Partitions
• Group Coherent Presentation

Looking up a previously created Entity

Example: lookup a previously-created DataWriter

 
    // Create a publisher and two writers. Each entity can optionally have
    // an arbitrary name assigned as part of its QoS.
    var publisher = participant.CreatePublisher(
        participant.DefaultPublisherQos.WithPublisherName("MyPublisher"));
 
    DataWriter<Shape> writer1 = publisher.CreateDataWriter(topic1);
 
    DataWriter<Shape> writer2 = publisher.CreateDataWriter(
        topic2,
        publisher.DefaultDataWriterQos.WithPublicationName("MyWriter2"));
 
    // ...
 
    // Look up the previously created writers by their topic name
    AnyDataWriter lookupWriter1 = publisher.LookupDataWriter(topic1.Name);
    Debug.Assert(writer1 == (DataWriter<Shape>) lookupWriter1);
    AnyDataWriter lookupWriter2 = publisher.LookupDataWriter(topic2.Name);
    Debug.Assert(writer2 == (DataWriter<Shape>) lookupWriter2);
 
    // Look up a writer by entity name (only if a name was assigned in the QoS)
    lookupWriter2 = publisher.LookupDataWriterByName("MyWriter2");
    Debug.Assert(writer2 == (DataWriter<Shape>) lookupWriter2);
 
    lookupWriter2 = participant.LookupDataWriter("MyPublisher::MyWriter2");
    Debug.Assert(writer2 == (DataWriter<Shape>) lookupWriter2);
 
    // Access all writers
    foreach (AnyDataWriter writer in publisher.DataWriters)
    {
        IAnyTopic relatedTopic = writer.TopicUntyped;
        Console.WriteLine($"DataWriter for topic {relatedTopic.Name} and type {relatedTopic.TypeName}");
    }
 
    // Access all writers in all publishers
    foreach (Publisher pub in participant.Publishers)
    {
        string pubName = pub.Qos.PublisherName.Name ?? "(unnamed)";
        Console.WriteLine($"Publisher: {pubName}");
        foreach (AnyDataWriter writer in pub.DataWriters)
        {
            IAnyTopic relatedTopic = writer.TopicUntyped;
            Console.WriteLine($"- DataWriter for topic {relatedTopic.Name} and type {relatedTopic.TypeName}");
        }
    }
 

Looking up a matched subscription

Example: lookup matched subscriptions

 
    // Look up all the subscriptions:
    foreach (var subscription in writer.GetMatchedSubscriptionData())
    {
        // subscription name is available if the reader was created with
        // DataReaderQos.WithSubscriptionName
        string name = subscription.SubscriptionName.Name;
        string typeName = subscription.TypeName;
        // ...
    }
 

See also Looking up matched publications and Entity Discovery.