// Using basic auth with API key
// Note in production, an API key should not be used in untrusted mobile/browser clients
var realtime = new AblyRealtime("<api key>");

// Using token auth with token string
// Note this token is not renewable - a token callback should be used in production
var realtime = new AblyRealtime(new ClientOptions { Token = "token" });

realtime.Connection.On(ConnectionEvent.Connected, args =>
{
    // Do stuff  
});

var realtime = new AblyRealtime(new ClientOptions("<api key>") { AutoConnect = false });
// Some code
realtime.Connect();

realtime.Connection.On(args =>
{
    var currentState = args.Current; // Current state the connection transitioned to
    var previousState = args.Previous; // Previous state
    var error = args.Reason; // If the connection error-ed the Reason object will be populated.
});

IRealtimeChannel channel = realtime.Channels.Get("test");

channel.Subscribe(message =>
{
    var name = message.Name;
    var data = message.Data;
});

channel.Subscribe("myEvent", message =>
{
    var name = message.Name;
    var data = message.Data;
});

channel.On(args =>
{
    var state = args.NewState; // Current channel State
    var error = args.Error; // If the channel error-ed it will be reflected here
});

channel.On(ChannelState.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 serializedData = JsonConvert.SerializeObject(message,
    new JsonSerializerSettings
    {
        ContractResolver = new CamelCasePropertyNamesContractResolver()
    });

var ablyMessage = new Message("name", serializedData) {Encoding = "json"};

channel.Publish(ablyMessage);

var history = await channel.HistoryAsync();
// Loop through current history page
foreach (var message in history.Items)
{
    // Do something with message
}
// Get next page.
var nextPage = await history.NextAsync();

var presenceHistory = await channel.Presence.HistoryAsync();
// Loop through the presence messages
foreach (var presence in presenceHistory.Items)
{
    // Do something with the messages
}

var presenceNextPage = await presenceHistory.NextAsync();

var channelParams = new ChannelParams();
channelParams.Add("delta", "vcdiff");
var channelOptions = new ChannelOptions();
channelOptions.Params = channelParams;
IRealtimeChannel channel = ably.Channels.Get(ChannelName, channelOptions);

var secret = Crypto.GetRandomKey();
var encryptedChannel = realtime.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)");

var maxBufferSize = 64 * 1024;
var options = new ClientOptions();
var websocketOptions = new MsWebSocketOptions() { SendBufferInBytes = maxBufferSize, ReceiveBufferInBytes = maxBufferSize };
options.TransportFactory = new MsWebSocketTransport.TransportFactory(websocketOptions);
var realtime = new AblyRealtime(options);

class CustomLogHandler : ILoggerSink
{
    public void LogEvent(LogLevel level, string message)
    {
        Console.WriteLine($"Handler LogLevel : {level}, Data :{message}");
    }
}

clientOpts.LogLevel = LogLevel.Debug;
clientOpts.LogHandler = new CustomLogHandler();

var client = new AblyRest("<api key>");
IRealtimeChannel channel = client.Channels.Get("chat");

await channel.PublishAsync("name", "data");

try 
{
    await channel.PublishAsync("name", "errorData");
} 
catch(AblyException ablyError) 
{
    // Log error
}

var serializedData = JsonConvert.SerializeObject(message,
    new JsonSerializerSettings
    {
        ContractResolver = new CamelCasePropertyNamesContractResolver()
    });

var ablyMessage = new Message("name", serializedData) {Encoding = "json"};

channel.Publish(ablyMessage);

var historyPage = await channel.HistoryAsync();
foreach (var message in historyPage.Items)
{
    // Do something with each message
}
// Get the next page
var nextHistoryPage = await historyPage.NextAsync();

var presence = await channel.Presence.GetAsync();
var first = presence.Items.FirstOrDefault();
var clientId = first.clientId; // 'clientId' of the first member present
var nextPresencePage = await presence.NextAsync();
foreach (var presenceMessage in nextPresencePage.Items)
{
    // Do stuff with next page presence messages
}

// Presence history
var presenceHistory = await channel.Presence.HistoryAsync();
foreach (var presenceMessage in presenceHistory.Items)
{
    // Do stuff with presence messages
}

var nextPage = await presenceHistory.NextAsync();
foreach (var presenceMessage in nextPage.Items)
{
    // Do stuff with next page messages
}

var rest = new AblyRest("API_KEY");

// e.g. ASP.Net server endpoint
app.MapGet("/token", async() => {
    string tokenRequest = await rest.Auth.CreateTokenRequestAsync();
    return Content(tokenRequest, "application/json"); // make sure to set `contentType` as json.
});

var options = new ClientOptions
{
    AuthCallback = async tokenParams =>
    {
        // Return serialized tokenRequest string or 'IO.Ably.TokenRequest' object
        return await TokenRequestStringFromYourServer(tokenParams); // tokenRequest will be used to obtain token from ably server.
    }
};
var client = new AblyRealtime(options);

var options = new ClientOptions
{
    AuthCallback = async tokenParams =>
    {
        string jwtToken = await getJwtTokenFromServer(tokenParams);
        int expiresIn = 3600; // assuming jwtToken has 1 hr expiry
        return new TokenDetails(jwtToken) { 
            Expires = DateTimeOffset.UtcNow.AddSeconds(expiresIn) 
        }; // jwt token will directly be used to authenticate with ably server.
    }
};

var stats = await client.StatsAsync();
var firstItem = stats.Items.First();
var nextStatsPage = await stats.NextAsync();

DateTimeOffset time = await client.TimeAsync();

ChannelDetails details = await channel.StatusAsync();
ChannelMetrics metrics = details.Status.Occupancy.Metrics;
// Do something with 'metrics.Publishers' etc

    var objectPayload = new
    {
        channels = new[] { "channel1", "channel2", "channel3", "channel4" },
        messages = new[]
        {
            new
            {
                name = "eventName",
                data = "foo",
            }
        }
    };
  var jsonPayload = JsonConvert.SerializeObject(objectPayload);
  var paginatedResponse = await ablyRest.RequestV2(HttpMethod.Post, "/messages", null, jsonPayload, null);

using System;

using IO.Ably;

namespace testing_ably_console
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");
            var realtime = new AblyRealtime("<api key>");
            IRealtimeChannel channel = realtime.Channels.Get("test");
            await channel.PublishAsync("greeting", "Hello World!");
            Console.WriteLine("Farewell World!");
        }
    }
}

using System;

using IO.Ably;

namespace testing_ably_console
{
    class Program
    {
        static void Main(string[] args)
        {
            MainAsync(args).GetAwaiter().GetResult();
        }

        static async Task MainAsync(string[] args)
        {
            Console.WriteLine("Hello World!");
            var realtime = new AblyRealtime("<api key>");
            IRealtimeChannel channel = realtime.Channels.Get("test");
            await channel.PublishAsync("greeting", "Hello World!");
        }
    }
}