public async Task ChannelSubscribe()
{
var realtime = new AblyRealtime(new ClientOptions(PlaceholderKey)
{
AutoConnect = false
});
IRealtimeChannel channel = realtime.Channels.Get("test");
// Or ...
IRealtimeChannel channel2 = realtime.Channels.Get("shortcut");
channel.Subscribe(message =>
{
var name = message.Name;
var data = message.Data;
});
channel.On(args =>
{
var state = args.Current; // Current channel State
var error = args.Error; // If the channel error-ed it will be reflected here
});
channel.On(ChannelEvent.Attached, args =>
{
// Do stuff when channel is attached
});
channel.Publish("greeting", "Hello World!");
channel.Publish("greeting", "Hello World!", (success, error) =>
{
// If 'Publish' succeeded 'success' is 'true'
// If 'Publish' failed 'success' is 'false' and 'error' will contain the specific error
});
var result = await channel.PublishAsync("greeting", "Hello World!");
// You can check if the message failed
if (result.IsFailure)
{
var error = result.Error; // The error reason can be accessed as well
}
var secret = Crypto.GenerateRandomKey();
var encryptedChannel = realtime.Channels.Get("encrypted", new ChannelOptions(secret));
encryptedChannel.Subscribe(message =>
{
var data = message.Data; // Sensitive data (encrypted before published)
});
encryptedChannel.Publish("name (not encrypted)", "sensitive data (encrypted before published)");
}
public async Task TestAttachChannel_Sending3Messages_EchoesItBack(Protocol protocol)
{
Logger.LogLevel = LogLevel.Debug;
;
// Arrange
var client = await GetRealtimeClient(protocol);
await client.WaitForState(ConnectionState.Connected);
ManualResetEvent resetEvent = new ManualResetEvent(false);
IRealtimeChannel target = client.Channels.Get("test" + protocol);
target.Attach();
await target.WaitForState(ChannelState.Attached);
ConcurrentQueue <Message> messagesReceived = new ConcurrentQueue <Message>();
int count = 0;
target.Subscribe(message =>
{
messagesReceived.Enqueue(message);
count++;
if (count == 3)
{
resetEvent.Set();
}
});
// Act
target.Publish("test1", "test 12");
target.Publish("test2", "test 123");
target.Publish("test3", "test 321");
bool result = resetEvent.WaitOne(8000);
await Task.Delay(100);
result.Should().BeTrue();
// Assert
messagesReceived.Count.ShouldBeEquivalentTo(3);
var messages = messagesReceived.ToList();
messages[0].Name.ShouldBeEquivalentTo("test1");
messages[0].Data.ShouldBeEquivalentTo("test 12");
messages[1].Name.ShouldBeEquivalentTo("test2");
messages[1].Data.ShouldBeEquivalentTo("test 123");
messages[2].Name.ShouldBeEquivalentTo("test3");
messages[2].Data.ShouldBeEquivalentTo("test 321");
}
static async Task Main(string[] args)
{
AblyRealtime ably = new AblyRealtime("HG2KVw.AjZP_A:W7VXUG9yw1-Cza6u");
IRealtimeChannel channel = ably.Channels.Get("[?delta=vcdiff]delta-sample-app");
VcdiffDecoder channelDecoder = new VcdiffDecoder();
channel.Subscribe(message =>
{
object data = message.Data;
try
{
if (VcdiffDecoder.IsDelta(data))
{
data = channelDecoder.ApplyDelta(data).AsObject();
}
else
{
channelDecoder.SetBase(data);
}
}
catch (Exception e)
{
/* Delta decoder error */
}
/* Process decoded data */
Console.WriteLine(JsonHelper.DeserializeObject <Data>(data as JObject));
});
ably.Connection.On(ConnectionEvent.Connected, change =>
{
Data data = new Data()
{
foo = "bar",
count = 1,
status = "active"
};
channel.Publish("data", data);
data.count++;
channel.Publish("data", data);
data.status = "inactive";
channel.Publish("data", data);
});
await Task.Run(() =>
{
Console.ReadLine();
});
}
public async Task SendingAMessageAttachesTheChannel_BeforeReceivingTheMessages(Protocol protocol)
{
Logger.LogLevel = LogLevel.Debug;
;
// Arrange
var client = await GetRealtimeClient(protocol);
IRealtimeChannel target = client.Channels.Get("test");
var messagesReceived = new List <Message>();
target.Subscribe(message =>
{
messagesReceived.Add(message);
_resetEvent.Set();
});
// Act
target.Publish("test", "test data");
target.State.Should().Be(ChannelState.Attaching);
_resetEvent.WaitOne(6000);
// Assert
target.State.Should().Be(ChannelState.Attached);
messagesReceived.Count.ShouldBeEquivalentTo(1);
messagesReceived[0].Name.ShouldBeEquivalentTo("test");
messagesReceived[0].Data.ShouldBeEquivalentTo("test data");
}
public async Task TestAttachChannel_Sending3Messages_EchoesItBack(Protocol protocol)
{
// Arrange
var client = await GetRealtimeClient(protocol);
ManualResetEvent resetEvent = new ManualResetEvent(false);
IRealtimeChannel target = client.Channels.Get("test" + protocol);
target.Attach();
List <Message> messagesReceived = new List <Message>();
int count = 0;
target.Subscribe(message =>
{
messagesReceived.Add(message);
count++;
if (count == 3)
{
resetEvent.Set();
}
});
// Act
target.Publish("test1", "test 12");
target.Publish("test2", "test 123");
target.Publish("test3", "test 321");
bool result = resetEvent.WaitOne(8000);
result.Should().BeTrue();
// Assert
messagesReceived.Count.ShouldBeEquivalentTo(3);
messagesReceived[0].Name.ShouldBeEquivalentTo("test1");
messagesReceived[0].Data.ShouldBeEquivalentTo("test 12");
messagesReceived[1].Name.ShouldBeEquivalentTo("test2");
messagesReceived[1].Data.ShouldBeEquivalentTo("test 123");
messagesReceived[2].Name.ShouldBeEquivalentTo("test3");
messagesReceived[2].Data.ShouldBeEquivalentTo("test 321");
}
public void Send(string message)
{
_channel.Publish(_publicAddress, message);
}