Hazelcast .NET Client

using System;
using System.Threading.Tasks;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class QueueExample
    {
        public static async Task Main(string[] args)
        {
            var options = new HazelcastOptionsBuilder()
                .With(args)
                .WithConsoleLogger()
                .Build();
 
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
 
            // Get a Blocking Queue called "my-distributed-queue"
            var queue = await client.GetQueueAsync<string>("my-distributed-queue");
            // Offer a String into the Distributed Queue
            await queue.PutAsync("item");
            // Poll the Distributed Queue and return the String
            await queue.PollAsync();
            //Timed blocking Operations
            await queue.OfferAsync("anotheritem", TimeSpan.FromMilliseconds(500));
            await queue.PollAsync(TimeSpan.FromSeconds(5));
            //Indefinitely blocking Operations
            await queue.PutAsync("yetanotheritem");
            Console.WriteLine(await queue.TakeAsync());
        }
    }
}

using System;
using System.Threading.Tasks;
using Hazelcast.DistributedObjects;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class TopicExample
    {
        private static void OnMessage(IHTopic<string> sender, TopicMessageEventArgs<string> args)
        {
            Console.WriteLine($"Got message " + args.Payload);
        }
 
        public static async Task Main(string[] args)
        {
            var options = new HazelcastOptionsBuilder()
                .With(args)
                .WithConsoleLogger()
                .Build();
 
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
 
            // get distributed topic from cluster
            await using var topic = await client.GetTopicAsync<string>("my-distributed-topic");
 
            // subscribe to event
            await topic.SubscribeAsync(on => on.Message(OnMessage));
 
            // publish a message to the Topic
            await topic.PublishAsync("Hello to distributed world");
 
            // allow event to trigger
            await Task.Delay(1_000);
 
            // destroy the topic
            await client.DestroyAsync(topic);
        }
    }
}

using System;
using System.Threading.Tasks;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class ListExample
    {
        public static async Task Main(string[] args)
        {
            var options = new HazelcastOptionsBuilder()
                .With(args)
                .WithConsoleLogger()
                .Build();
 
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
 
            // Get the Distributed List from Cluster.
            await using var list = await client.GetListAsync<string>("my-distributed-list");
 
            // Add elements to the list
            await list.AddAsync("item1");
            await list.AddAsync("item2");
 
            // Remove the first element
            Console.WriteLine("Removed: " + await list.RemoveAsync(0));
            // There is only one element left
            Console.WriteLine("Current size is " + await list.GetSizeAsync());
            // Clear the list
            await list.ClearAsync();
 
            await client.DestroyAsync(list);
        }
    }
}

using System;
using System.Threading.Tasks;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class ReplicatedMapExample
    {
        public static async Task Main(string[] args)
        {
            var options = new HazelcastOptionsBuilder()
                .With(args)
                .WithConsoleLogger()
                .Build();
 
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
 
            // Get a Replicated Map called "my-replicated-map"
            await using var map = await client.GetReplicatedMapAsync<string, string>("my-replicated-map");
            // Put and Get a value from the Replicated Map
            var replacedValue = await map.PutAsync("key", "value"); // key/value replicated to all members
            Console.WriteLine("replacedValue = " + replacedValue); // Will be null as its first update
            var value = await map.GetAsync("key"); // the value is retrieved from a random member in the cluster
            Console.WriteLine("value for key = " + value);
        }
    }
}

using System;
using System.Threading.Tasks;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class SetExample
    {
        public static async Task Main(string[] args)
        {
            var options = new HazelcastOptionsBuilder()
                .With(args)
                .WithConsoleLogger()
                .Build();
 
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
 
            // Get the Distributed Set from Cluster.
            await using var set = await client.GetSetAsync<string>("my-distributed-set");
 
            // Add items to the set with duplicates
            await set.AddAsync("item1");
            await set.AddAsync("item1");
            await set.AddAsync("item2");
            await set.AddAsync("item2");
            await set.AddAsync("item2");
            await set.AddAsync("item3");
 
            // Get the items. Note that there are no duplicates.
            await foreach (var item in set)
            {
                Console.WriteLine(item);
            }
 
            await client.DestroyAsync(set);
        }
    }
}

using System;
using System.Threading.Tasks;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class MultiMapExample : ExampleBase
    {
        public async Task Run(string[] args)
        {
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(BuildExampleOptions(args));
 
            // Get the Distributed MultiMap from Cluster.
            await using var multiMap = await client.GetMultiMapAsync("my-distributed-multimap");
            // Put values in the map against the same key
            await multiMap.PutAsync("my-key", "value1");
            await multiMap.PutAsync("my-key", "value2");
            await multiMap.PutAsync("my-key", "value3");
            // Print out all the values for associated with key called "my-key"
            var values = await multiMap.GetAsync("my-key");
            foreach (var item in values)
            {
                Console.WriteLine(item);
            }
 
            // remove specific key/value pair
            await multiMap.RemoveAsync("my-key", "value2");
        }
    }
}

using System;
using System.Threading.Tasks;
 
namespace Hazelcast.Examples.WebSite
{
    // ReSharper disable once UnusedMember.Global
    public class RingBufferExample
    {
        public static async Task Main(string[] args)
        {
            var options = new HazelcastOptionsBuilder()
                .With(args)
                .WithConsoleLogger()
                .Build();
 
            // create an Hazelcast client and connect to a server running on localhost
            await using var client = await HazelcastClientFactory.StartNewClientAsync(options);
 
            await using var rb = await client.GetRingBufferAsync<long>("rb");
 
            // add two items into ring buffer
            await rb.AddAsync(100);
            await rb.AddAsync(200);
 
            // we start from the oldest item.
            // if you want to start from the next item, call rb.tailSequence()+1
            var sequence = await rb.GetHeadSequenceAsync();
            Console.WriteLine(await rb.ReadOneAsync(sequence));
            sequence += 1;
            Console.WriteLine(await rb.ReadOneAsync(sequence));
 
            await client.DestroyAsync(rb);
        }
    }
}