Create a .NET client that publishes data through topics on Diffusion™ Cloud .

1. Create a .NET project that references the DLL file that can be downloaded from the following location: Download the .NET assembly

   Diffusion.Client

   The assembly contains the interfaces classes and interfaces that you use when creating a control client.

   Use the following .NET CLI command:

   dotnet add package Diffusion.Client -v 6.11.6

2. In your project, create a C# file that uses the following packages:

   using System;
   using System.Threading;
   using PushTechnology.ClientInterface.Client.Callbacks;
   using PushTechnology.ClientInterface.Client.Factories;
   using PushTechnology.ClientInterface.Client.Features.Control.Topics;
   using PushTechnology.ClientInterface.Data.JSON;
   
   namespace PushTechnology.ClientInterface.GettingStarted {
   }
   

3. Create a Main method.

       public sealed class PublishingClient
       {
           public static void Main( string[] args ) {
   
           }
       }

4. Inside the Main method, connect to Diffusion Cloud .

           public static void Main( string[] args ) {
               // Connect using a principal with 'modify_topic' and 'update_topic'
               // permissions
               var session = Diffusion.Sessions.Principal("principal").Password("password").Open("ws://host:80");
           }

   Or you can connect securely to Diffusion Cloud through port 443 using Secure Sockets Layer (SSL):

           .Open("wss://host:443");

   Replace the host, principal, and password values with your own information.
   You can choose to connect anonymously if anonymous sessions are assigned the modify_topic and update_topic permissions. However, we do not recommend that anonymous sessions are given write access to data on Diffusion Cloud .
5. Next, in the Main method, get the TopicControl and TopicUpdateControl features.

               // Get the TopicControl and TopicUpdateControl features
               var topicControl = session.TopicControl;
               var updateControl = session.TopicUpdateControl;
   

   The TopicControl feature enables a client to create and delete topics. For more information, see .
   The TopicUpdateControl feature enables a client to publish updates to a topic. For more information, see .
6. Next, in the Main method, use the TopicControl feature to create the foo/counter JSON topic.

               // Create a JSON topic 'foo/counter'
               var topic = "foo/counter";
               var addCallback = new AddCallback();
               topicControl.AddTopicFromValue(
                   topic,
                   Diffusion.DataTypes.JSON.FromJSONString( "{\"date\":\"To be updated\",\"time\":\"To be updated\"}" ),
                   addCallback );
   
                   // Wait for the OnTopicAdded callback, or a failure
                   if ( !addCallback.Wait( TimeSpan.FromSeconds( 5 ) ) ) {
                       Console.WriteLine( "Callback not received within timeout." );
                       session.Close();
                       return;
                   } else if ( addCallback.Error != null ) {
                       Console.WriteLine( "Error : {0}", addCallback.Error.ToString() );
                       session.Close();
                       return;
                }

   The AddTopicFromValue() method requires a callback, which you must create.
7. Implement an instance of ITopicControlAddCallback as an internal sealed class.

        internal sealed class AddCallback : ITopicControlAddCallback {
           private readonly AutoResetEvent resetEvent = new AutoResetEvent( false );
   
           /// <summary>
           /// Any error from this AddCallback will be stored here.
           /// </summary>
           public Exception Error {
               get;
               private set;
           }
   
           /// <summary>
           /// Constructor.
           /// </summary>
           public AddCallback() {
               Error = null;
           }
   
           /// <summary>
           /// This is called to notify that a call context was closed prematurely, typically due to a timeout or the
           /// session being closed.
           /// </summary>
           /// <remarks>
           /// No further calls will be made for the context.
           /// </remarks>
           public void OnDiscard() {
               Error = new Exception( "This context was closed prematurely." );
               resetEvent.Set();
           }
   
           /// <summary>
           /// This is called to notify that the topic has been added.
           /// </summary>
           /// <param name="topicPath">The full path of the topic that was added.</param>
           public void OnTopicAdded( string topicPath ) {
               Console.WriteLine( "Topic {0} added.", topicPath );
               resetEvent.Set();
           }
   
           /// <summary>
           /// This is called to notify that an attempt to add a topic has failed.
           /// </summary>
           /// <param name="topicPath">The topic path as supplied to the add request.</param>
           /// <param name="reason">The reason for failure.</param>
           public void OnTopicAddFailed( string topicPath, TopicAddFailReason reason ) {
               Error = new Exception( string.Format( "Failed to add topic {0} : {1}", topicPath, reason ) );
               resetEvent.Set();
           }
   
           /// <summary>
           /// Wait for one of the callbacks for a given time.
           /// </summary>
           /// <param name="timeout">Time to wait for the callback.</param>
           /// <returns><c>true</c> if either of the callbacks has been triggered. Otherwise <c>false</c>.</returns>
           public bool Wait( TimeSpan timeout ) {
               return resetEvent.WaitOne( timeout );
           }
       }

8. Back in the Main method, loop once a second updating the foo/counter topic with an incrementing count.
   Use the updateControl.Updater.Update() method to update a topic without locking that topic.

               var updateCallback = new UpdateCallback( topic );
               for ( var i = 0; i < 1000; ++i ) {
                   updateControl.Updater.Update( topic, i.ToString(), updateCallback );
   
                   Thread.Sleep( 1000 );
               }

   The Update() method requires a callback, which you must create.
9. Implement an instance of ITopicUpdaterUpdateCallback as an internal sealed class.

                   internal sealed class UpdateCallback : ITopicUpdaterUpdateCallback {
                   private readonly string topicPath;
   
                   /// <summary>
                   /// Constructor.
                   /// </summary>
                   /// <param name="topicPath">The topic path.</param>
                   public UpdateCallback( string topicPath ) {
                       this.topicPath = topicPath;
                   }
   
                   /// <summary>
                   /// Notification of a contextual error related to this callback.
                   /// </summary>
                   /// <remarks>
                   /// Situations in which <code>OnError</code> is called include the session being closed, a communication
                   /// timeout, or a problem with the provided parameters. No further calls will be made to this callback.
                   /// </remarks>
                   /// <param name="errorReason">A value representing the error.</param>
                   public void OnError( ErrorReason errorReason ) {
                       Console.WriteLine( "Topic {0} could not be updated : {1}", topicPath, errorReason );
                   }
   
                   /// <summary>
                   /// Indicates a successful update.
                   /// </summary>
                   public void OnSuccess() {
                       Console.WriteLine( "Topic {0} updated successfully.", topicPath );
                   }
               }

10. Finally, in the Main method, close the session between your client and Diffusion Cloud .

                // Close session
                session.Close();

11. Compile and run your client.