[ActorService(Name = nameof(IBrokerActor))] //required because of interface operations
internal class PubSubActor : ServiceFabric.PubSubActors.BrokerActor, Interfaces.IBrokerActor
{
	public PubSubActor() 
	{
        //optional: provide a logging callback
		ActorEventSourceMessageCallback = message => ActorEventSource.Current.ActorMessage(this, message);
	}
}

internal sealed class PubSubService : BrokerService
{
    public PubSubService(StatefulServiceContext context)
       : base(context)
    {
	//optional: provide a logging callback
	ServiceEventSourceMessageCallback = message => ServiceEventSource.Current.ServiceMessage(this, message);
    }
}

	[StatePersistence(StatePersistence.Persisted)]
	[ActorService(Name = nameof(IRelayBrokerActor))]
	internal class PubkSubRelayActor : RelayBrokerActor, IPubkSubRelayActor
	{
		public PubkSubRelayActor()
		{
			//optional: provide a logging callback
			ActorEventSourceMessageCallback = message => ActorEventSource.Current.ActorMessage(this, message);
		}
	}

[DataContract]
public class PublishedMessageOne
{
	[DataMember]
	public string Content { get; set; }
}
[DataContract]
public class PublishedMessageTwo
{
	[DataMember]
	public string Content { get; set; }
}

public interface ISubscribingActor : ISubscriberActor
	{
		// allow external callers to manipulate register/unregister on this sample actor:
		//for regular messaging:
		Task RegisterAsync(); 
		Task UnregisterAsync();
		//for relayed messaging:
		Task RegisterWithRelayAsync();
		Task UnregisterWithRelayAsync();
		//for service broker messaging:
		Task RegisterWithBrokerServiceAsync();
		Task UnregisterWithBrokerServiceAsync();
	}

using ServiceFabric.PubSubActors.SubscriberActors;

[ActorService(Name = nameof(ISubscribingActor))]
[StatePersistence(StatePersistence.None)]
internal class SubscribingActor : Actor, ISubscribingActor
{
	private const string WellKnownRelayBrokerId = "WellKnownRelayBroker";
	//register to the default broker:
	public Task RegisterAsync()
	{
		return this.RegisterMessageTypeAsync(typeof(PublishedMessageOne)); //register as subscriber for this type of messages
	}
	public Task UnregisterAsync()
	{
		return this.UnregisterMessageTypeAsync(typeof(PublishedMessageOne), true); //unregister as subscriber for this type of messages
	}
	
	//for large scale messaging, register a relay to the original broker, and register as a subscriber to that relay:
	public Task RegisterWithRelayAsync()
	{
		//register as subscriber for this type of messages at the relay broker
		//using the default Broker for the message type as source for the relay broker
		return this.RegisterMessageTypeWithRelayBrokerAsync(typeof(PublishedMessageOne), new ActorId(WellKnownRelayBrokerId), null); 
	}
	public Task UnregisterWithRelayAsync()
	{
		//unregister as subscriber for this type of messages at the relay broker
		return this.UnregisterMessageTypeWithRelayBrokerAsync(typeof(PublishedMessageOne), new ActorId(WellKnownRelayBrokerId), null,  true); 
	}
	
 	public Task RegisterWithBrokerServiceAsync()
        {
            return this.RegisterMessageTypeWithBrokerServiceAsync(typeof(PublishedMessageTwo));
        }

        public Task UnregisterWithBrokerServiceAsync()
        {
            return this.UnregisterMessageTypeWithBrokerServiceAsync(typeof(PublishedMessageTwo), true);
        }

	public Task ReceiveMessageAsync(MessageWrapper message)
	{
		var payload = this.Deserialize<PublishedMessageOne>(message);
		ActorEventSource.Current.ActorMessage(this, $"Received message: {payload.Content}");
		//TODO: handle message
		return Task.FromResult(true);
	}
}

//from outside the Actor, using the custom interface ISubscribingActor
ActorId actorId = new ActorId("SubActor");
string applicationName = "fabric:/MyServiceFabricApp"; //replace with your application name
ISubscriberActor subActor = ActorProxy.Create<ISubscribingActor>(actorId, applicationName, nameof(ISubscribingActor));
subActor.RegisterAsync().GetAwaiter().GetResult();

using ServiceFabric.PubSubActors.Interfaces;
using ServiceFabric.PubSubActors.SubscriberServices;

internal sealed class SubscribingStatefulService : StatefulService, ISubscriberService
{
	public SubscribingStatefulService(StatefulServiceContext serviceContext) : base(serviceContext)
	{
	}

	public SubscribingStatefulService(StatefulServiceContext serviceContext, IReliableStateManagerReplica 						reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
	{
	}
		
	protected override IEnumerable<ServiceReplicaListener> CreateServiceReplicaListeners()
	{
		//add SubscriberCommunicationListener for receiving published messages.
		yield return new ServiceReplicaListener(p => new SubscriberCommunicationListener(this, p), "StatefulSubscriberCommunicationListener);
	}

	protected override Task OnOpenAsync(ReplicaOpenMode openMode, CancellationToken cancellationToken)
	{
		return RegisterAsync();
	}
		
	public async Task RegisterAsync()
	{	
		//register with BrokerActor:	
	    	await this.RegisterMessageTypeAsync(typeof(PublishedMessageOne));
	    	//register with BrokerService:
            	await this.RegisterMessageTypeWithBrokerServiceAsync(typeof(PublishedMessageTwo));
	}

	public async Task UnregisterAsync()
	{
		//unregister with BrokerActor:	
		await this.UnregisterMessageTypeAsync(typeof(PublishedMessageOne), true);
		//unregister with BrokerService:
            	await this.UnregisterMessageTypeWithBrokerServiceAsync(typeof(PublishedMessageTwo), true);
	}

	//receives published messages:
	public Task ReceiveMessageAsync(MessageWrapper message)
	{
		var payload = this.Deserialize<PublishedMessageOne>(message);
		ServiceEventSource.Current.ServiceMessage(this, $"Received message: {payload.Content}");
		//TODO: handle message
		return Task.FromResult(true);
	}
}

internal sealed class SubscribingToRelayStatefulService : StatefulService, ISubscriberService
{
	private const string WellKnownRelayBrokerId = "WellKnownRelayBroker";
	public SubscribingToRelayStatefulService(StatefulServiceContext serviceContext) : base(serviceContext)
	{
	}
	public SubscribingToRelayStatefulService(StatefulServiceContext serviceContext, IReliableStateManagerReplica reliableStateManagerReplica) : base(serviceContext, reliableStateManagerReplica)
	{
	}

	protected override IEnumerable<ServiceReplicaListener> CreateServiceReplicaListeners()
	{
		yield return new ServiceReplicaListener(p => new SubscriberCommunicationListener(this, p), "RelayStatefullSubscriberCommunicationListener");
	}

	protected override async Task OnOpenAsync(ReplicaOpenMode openMode, CancellationToken cancellationToken)
	{
		await RegisterAsync();
		//do other stuff
	}

	public Task RegisterAsync()
	{
		return this.RegisterMessageTypeWithRelayBrokerAsync(typeof(PublishedMessageOne), new ActorId(WellKnownRelayBrokerId), null);
	}

	public Task UnregisterAsync()
	{
		return this.UnregisterMessageTypeWithRelayBrokerAsync(typeof(PublishedMessageOne), new ActorId(WellKnownRelayBrokerId), null, true);
	}

	public Task ReceiveMessageAsync(MessageWrapper message)
	{
		var payload = this.Deserialize<PublishedMessageOne>(message);
		ServiceEventSource.Current.ServiceMessage(this, $"Received message: {payload.Content}");
		//TODO: handle message
		return Task.FromResult(true);
	}
}

public interface IPublishingActor : IActor
{
	//enables external callers to trigger a publish action, not required for functionality
	Task<string> PublishMessageOneAsync();
	Task<string> PublishMessageTwoAsync();
}

using ServiceFabric.PubSubActors.PublisherActors;
[StatePersistence(StatePersistence.None)]
internal class PublishingActor : Actor, IPublishingActor
{
	//publish to BrokerActor
	async Task<string> IPublishingActor.PublishMessageOneAsync()
	{
		ActorEventSource.Current.ActorMessage(this, "Publishing Message");
		await this.PublishMessageAsync(new PublishedMessageOne {Content = "Hello PubSub World, from Actor!"});
		return "Message published to Broker Actor";
	}
	
	//publish to BrokerService
	async Task<string> IPublishingActor.PublishMessageTwoAsync()
        {
            ActorEventSource.Current.ActorMessage(this, "Publishing Message");

            await this.PublishMessageToBrokerServiceAsync(new PublishedMessageTwo { Content = "Hello PubSub World, from Actor, using 	Broker Service!" });
            return "Message published to broker service";
        }
}

string applicationName = "fabric:/MyServiceFabricApp";  //replace with your application name
var actorId = new ActorId("PubActor");
pubActor = ActorProxy.Create<IPublishingActor>(actorId, applicationName);
pubActor.PublishMessageOneAsync()

[ServiceContract]
public interface IPublishingStatelessService : IService
{
	//allows external callers to trigger a publish action, not required for functionality
	[OperationContract]
	Task<string> PublishMessageOneAsync();
	[OperationContract]
	Task<string> PublishMessageTwoAsync();
}

internal sealed class PublishingStatelessService : StatelessService, IPublishingStatelessService
{
	protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
	{
		yield return new ServiceInstanceListener(context => new FabricTransportServiceRemotingListener(context, this), "StatelessFabricTransportServiceRemotingListener");
	}

	async Task<string> IPublishingStatelessService.PublishMessageOneAsync()
	{
		ServiceEventSource.Current.ServiceMessage(this, "Publishing Message");
		await this.PublishMessageAsync(new PublishedMessageOne { Content = "Hello PubSub World, from Service!" });
		return "Message published tot broker actor";
	}
	
	async Task<string> IPublishingStatelessService.PublishMessageTwoAsync()
        {
            ServiceEventSource.Current.ServiceMessage(this, "Publishing Message");
            await this.PublishMessageToBrokerServiceAsync(new PublishedMessageTwo { Content = "Hello PubSub World, from Service, using Broker Service!" });
            return "Message published to broker service";
        }
}