public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<string, string>("listener-example");
var cdown = new CountdownEvent(2);
map.AddEntryListener(new EntryAdapter<string, string>
{
Added = e =>
{
Console.WriteLine("Key '{0}' with value ' {1}' was added.", e.GetKey(), e.GetValue());
cdown.Signal();
},
Removed = e =>
{
Console.WriteLine("Key '{0}' with value ' {1}' was removed.", e.GetKey(), e.GetOldValue());
cdown.Signal();
}
}, true);
map.Put("key", "value");
map.Remove("key");
cdown.Wait();
map.Destroy();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var semaphore = client.GetSemaphore("example-semaphore");
semaphore.Init(1);
var i = 0;
Action increment = () =>
{
for (var j = 0; j < 100; j++)
{
semaphore.Acquire();
try
{
i++;
}
finally
{
semaphore.Release();
}
}
};
var task1 = Task.Factory.StartNew(increment);
var task2 = Task.Factory.StartNew(increment);
Task.WaitAll(task1, task2);
Console.WriteLine("Final value: " + i);
semaphore.Destroy();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var list = client.GetList<string>("list-example");
list.Add("item1");
list.Add("item2");
list.Add("item3");
Console.WriteLine("Get: " + list[0]);
Console.WriteLine("Enumerator : " + string.Join(", ", list));
Console.WriteLine("Contains: " + string.Join(", ", list.Contains("item2")));
Console.WriteLine("Count: " + string.Join(", ", list.Count));
Console.WriteLine("Sublist: " + string.Join(", ", list.SubList(0, 2)));
list.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var list = client.GetList<string>("collection-listener-example");
var cdown = new CountdownEvent(3);
list.AddItemListener(new ItemListener<string>
{
OnItemAdded = e =>
{
Console.WriteLine("Item added: " + e.GetItem());
cdown.Signal();
},
OnItemRemoved = e =>
{
Console.WriteLine("Item removed: " + e.GetItem());
cdown.Signal();
}
}, true);
list.Add("item1");
list.Add("item2");
list.Remove("item1");
cdown.Wait();
list.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var options = new TransactionOptions();
options.SetTransactionType(TransactionOptions.TransactionType.OnePhase);
var ctx = client.NewTransactionContext(options);
ctx.BeginTransaction();
try
{
var txMap = ctx.GetMap<string, string>("txn-map");
txMap.Put("foo", "bar");
ctx.CommitTransaction();
}
catch
{
ctx.RollbackTransaction();
}
var map = client.GetMap<string, string>("txn-map");
Console.WriteLine("Value of foo is " + map.Get("key"));
map.Destroy();
client.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
config.GetSerializationConfig()
.AddDataSerializableFactory(ExampleDataSerializableFactory.FactoryId,
new ExampleDataSerializableFactory());
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<int, Employee>("identified-data-serializable-example");
var employee = new Employee { Id = 1, Name = "the employee"};
Console.WriteLine("Adding employee: " + employee);
map.Put(employee.Id, employee);
var e = map.Get(employee.Id);
Console.WriteLine("Gotten employee: " + e);
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<string, string>("simple-example");
map.Put("key", "value");
map.Put("key2", "value2");
Console.WriteLine("Key: " + map.Get("key"));
Console.WriteLine("Values : " + string.Join(", ", map.Values()));
Console.WriteLine("KeySet: " + string.Join(", ", map.KeySet()));
Console.WriteLine("Size: " + string.Join(", ", map.Size()));
Console.WriteLine("EntrySet: " + string.Join(", ", map.EntrySet()));
Console.WriteLine("ContainsKey: " + string.Join(", ", map.ContainsKey("key")));
Console.WriteLine("ContainsValue: " + string.Join(", ", map.ContainsValue("value")));
map.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<string, string>("map-lock-example");
map.Put("key", "value");
map.Lock("key");
var task = Task.Factory.StartNew(() =>
{
map.Put("key", "newValue");
Console.WriteLine("Put new value");
});
try
{
var value = map.Get("key");
//do something with the value..
Thread.Sleep(5000);
}
finally
{
map.Unlock("key");
}
task.Wait();
Console.WriteLine("New value: " + map.Get("key"));
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var ringbuffer = client.GetRingbuffer<string>("ringbuffer-example");
var writer = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
ringbuffer.Add("item " + i);
}
});
var reader = Task.Factory.StartNew(() =>
{
var sequence = ringbuffer.HeadSequence();
while (sequence < 100)
{
var item = ringbuffer.ReadOne(sequence++);
Console.WriteLine("Reading value " + item);
}
});
Task.WaitAll(reader, writer);
ringbuffer.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var topic = client.GetTopic<string>("topic-example");
var countdown = new CountdownEvent(100);
topic.AddMessageListener(m =>
{
Console.WriteLine("Got message: " + m.GetMessageObject());
countdown.Signal();
});
var publisher = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
topic.Publish("Message " + i);
}
});
countdown.Wait();
topic.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var queue = client.GetQueue<string>("queue-example");
var producer = Task.Factory.StartNew(() =>
{
for (var i = 0; i < 100; i++)
{
queue.Offer("value " + i);
}
});
var consumer = Task.Factory.StartNew(() =>
{
var nConsumed = 0;
string e;
while (nConsumed++ < 100 && (e = queue.Take()) != null)
{
Console.WriteLine("Consuming " + e);
}
});
Task.WaitAll(producer, consumer);
queue.Destroy();
client.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var generator = client.GetIdGenerator("example-id-generator");
generator.Init(1000);
Action generateId = () =>
{
for (var i = 0; i < 100; i++)
{
Console.WriteLine("Generated id: " + generator.NewId());
}
};
var task1 = Task.Factory.StartNew(generateId);
var task2 = Task.Factory.StartNew(generateId);
Task.WaitAll(task1, task2);
generator.Destroy();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var latch = client.GetCountDownLatch("countdown-latch-example");
latch.TrySetCount(2);
var task1 = Task.Factory.StartNew(() =>
{
//do some work
Thread.Sleep(5000);
latch.CountDown();
});
var task2 = Task.Factory.StartNew(() =>
{
//do some work
Thread.Sleep(10000);
latch.CountDown();
});
latch.Await(20, TimeUnit.Seconds);
Console.WriteLine("Tasks completed");
latch.Destroy();
}
// static HazelcastInstance second;
/// <exception cref="System.Exception"></exception>
public static void Mainwq(string[] args)
{
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
q = client.GetQueue<object>("test");
Test1();
}
static void Main2(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("127.0.0.1");
var hc = HazelcastClient.NewHazelcastClient(clientConfig);
var listener1 = new EntryAdapter<string, string>(
@event => Console.WriteLine("ADD"),
@event => Console.WriteLine("REMOVE"),
@event => Console.WriteLine("UPDATE"),
@event => Console.WriteLine("EVICTED"));
var map = hc.GetMap<string, string>("default");
string reg1 = map.AddEntryListener(listener1, false);
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
var nearCacheConfig = new NearCacheConfig();
nearCacheConfig.SetMaxSize(1000)
.SetInvalidateOnChange(true)
.SetEvictionPolicy("Lru")
.SetInMemoryFormat(InMemoryFormat.Binary);
config.AddNearCacheConfig("nearcache-map-*", nearCacheConfig);
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<string, string>("nearcache-map-1");
for (var i = 0; i < 1000; i++)
{
map.Put("key" + i, "value" + i);
}
var sw = new Stopwatch();
sw.Start();
for (var i = 0; i < 1000; i++)
{
map.Get("key" + i);
}
Console.WriteLine("Got values in " + sw.ElapsedMilliseconds + " millis");
sw.Restart();
for (var i = 0; i < 1000; i++)
{
map.Get("key" + i);
}
Console.WriteLine("Got cached values in " + sw.ElapsedMilliseconds + " millis");
map.Destroy();
client.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <int, int>("predicate-example");
Console.WriteLine("Populating map");
for (int i = 0; i < 1000; i++)
{
map.Put(i, i);
}
Console.WriteLine("Map size: " + map.Size());
var partitionKey = 10;
//all keys on the same partition of the partitionKey will be returned
var allPartitionKeys = map.KeySet(new PartitionPredicate(partitionKey, Predicates.True()));
//keys less than 100 and on the same partition of the partitionKey will be returned
var result = map.KeySet(new PartitionPredicate(partitionKey, Predicates.IsLessThan("this", 100)));
Console.Write("\nKey set: ");
foreach (var key in result)
{
Console.Write(key + ", ");
}
client.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var theLock = client.GetLock("lock-example");
var i = 0;
Action increment = () =>
{
for (var j = 0; j < 100; j++)
{
theLock.Lock();
try
{
i++;
}
finally
{
theLock.Unlock();
}
}
};
var task1 = Task.Factory.StartNew(increment);
var task2 = Task.Factory.StartNew(increment);
Task.WaitAll(task1, task2);
Console.WriteLine("final value: " + i);
theLock.Destroy();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetSerializationConfig().AddPortableFactory(1, new ExamplePortableFactory());
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<int, Customer>("portable-example");
var customer = new Customer {Id = 1, LastOrder = DateTime.UtcNow, Name = "first-customer"};
Console.WriteLine("Adding customer: " + customer);
map.Put(customer.Id, customer);
var c = map.Get(customer.Id);
Console.WriteLine("Gotten customer: " + c);
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var clientConfig = new ClientConfig();
var clientNetworkConfig = clientConfig.GetNetworkConfig();
clientNetworkConfig.GetCloudConfig()
.SetEnabled(true)
.SetDiscoveryToken("DISCOVERY_TOKEN_HASH"); //Discovery token copied from Cloud console
var client = HazelcastClient.NewHazelcastClient(clientConfig);
var map = client.GetMap <string, string>("ssl-example");
map.Put("key", "value");
Console.WriteLine("Key: " + map.Get("key"));
map.Destroy();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var reset = new ManualResetEventSlim();
config.AddListenerConfig(new ListenerConfig(new MembershipListener
{
OnMemberAdded = m =>
{
Console.WriteLine("Added member: " + m.GetMember());
reset.Set();
}
}));
var client = HazelcastClient.NewHazelcastClient(config);
reset.Wait();
client.Shutdown();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var reset = new ManualResetEventSlim();
config.AddListenerConfig(new ListenerConfig(new LifecycleListener(e =>
{
Console.WriteLine("new state: " + e.GetState());
if (e.GetState() == LifecycleEvent.LifecycleState.ClientConnected)
{
reset.Set();
}
})));
var client = HazelcastClient.NewHazelcastClient(config);
reset.Wait();
client.Shutdown();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var semaphore = client.GetSemaphore("example-semaphore");
semaphore.Init(1);
var i = 0;
Action increment = () =>
{
for (var j = 0; j < 100; j++)
{
semaphore.Acquire();
try
{
i++;
}
finally
{
semaphore.Release();
}
}
};
var task1 = Task.Factory.StartNew(increment);
var task2 = Task.Factory.StartNew(increment);
Task.WaitAll(task1, task2);
Console.WriteLine("Final value: " + i);
semaphore.Destroy();
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var theLock = client.GetLock("lock-example");
var i = 0;
Action increment = () =>
{
for (var j = 0; j < 100; j++)
{
theLock.Lock();
try
{
i++;
}
finally
{
theLock.Unlock();
}
}
};
var task1 = Task.Factory.StartNew(increment);
var task2 = Task.Factory.StartNew(increment);
Task.WaitAll(task1, task2);
Console.WriteLine("final value: " + i);
theLock.Destroy();
}
static void Mainzz(string[] args)
{
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("127.0.0.1");
clientConfig.GetSerializationConfig().AddDataSerializableFactory(1, new MyDataSerializableFactory());
IHazelcastInstance client = HazelcastClient.NewHazelcastClient(clientConfig);
//All cluster operations that you can do with ordinary HazelcastInstance
IMap<string, DataSerializableType> map = client.GetMap<string, DataSerializableType>("imap");
ISerializationService service = ((HazelcastClientProxy)client).GetSerializationService();
object obj=new DataSerializableType(1000,1000);
long start = Clock.CurrentTimeMillis();
var data = service.ToData(obj);
var dataSerializableType = service.ToObject<DataSerializableType>(data);
long diff = Clock.CurrentTimeMillis()- start;
Console.WriteLine("Serialization time:"+diff);
Console.ReadKey();
}
private static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap<string, string>("simple-example");
var tasks = new List<Task>();
for (var i = 0; i < 100; i++)
{
var key = "key " + i;
var task = map.PutAsync(key, " value " + i).ContinueWith(t => { Console.WriteLine("Added " + key); });
tasks.Add(task);
}
Task.WaitAll(tasks.ToArray());
map.Destroy();
client.Shutdown();
}
public Cache(string[] hosts)
{
try
{
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress(hosts);
clientConfig.GetSerializationConfig().
AddPortableFactory(PersonPortableFactory.FACTORY_ID, new PersonPortableFactory());
_hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
_map = _hazelcast.GetMap <int, Person>("persons");
Console.WriteLine("Hazelcast cluster addresses:");
foreach (var h in hosts)
{
Console.WriteLine(h);
}
}
catch (Exception e)
{
Console.WriteLine("Hazelcast: connection failed.");
Console.WriteLine(e.Message);
}
}
private void ConnectToHZ()
{
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("127.0.0.1");
clientConfig.GetSerializationConfig().AddPortableFactory(PortableFactory.FactoryId, new PortableFactory());
client = HazelcastClient.NewHazelcastClient(clientConfig);
map = client.GetMap<CarKey, Car>("cars");
//if (map != null && map.Size() == 0)
//{
// //FILL
// for (int i = 1; i <= 100; i++)
// {
// CarKey key = new CarKey(i,"", "CAR_BRAND-"+i, "Model"+i, 1900+ i);
// Car car = new Car();
// car.ModelBody = "";
// car.ModelEngineCc = 1000+ i * 10;
// car.ModelEngineCyl = i % 12;
// car.ModelEngineType = "type"+i;
// car.ModelEngineValvesPerCyl = 2;
// car.ModelEnginePowerPs = 50 % i;
// car.ModelEngineCompression = "";
// car.ModelEngineFuel = "Gas";
// car.ModelTopSpeedKph = 150 + i;
// car.Model0To100Kph = i;
// car.ModelTransmissionType = "type"+i;
// car.ModelWeightKg = 800 + i*2;
// map.Put(key, car);
// }
//}
bindDataSet();
}
public async Task <ActionResult <IEnumerable <MetricItem> > > GetMetricItems(string userName)
{
// We should clear context each time
ClearContext();
string hazelcastIP = Environment.GetEnvironmentVariable("ENV_HIP");
if (string.IsNullOrEmpty(hazelcastIP))
{
hazelcastIP = "127.0.0.1";
}
var cfg = new ClientConfig();
cfg.GetNetworkConfig().AddAddress(hazelcastIP);
var client = HazelcastClient.NewHazelcastClient(cfg);
IMap <string, double> mapMetricsAggregatedData = client.GetMap <string, double>("metrics-aggregated-data");
ICollection <string> keys = mapMetricsAggregatedData.KeySet();
MetricItem metricItem;
foreach (var key in keys)
{
string[] keyParts = key.Split('*');
if (String.Equals(userName, keyParts[0]))
{
metricItem = new MetricItem();
metricItem.Id = key;
metricItem.Value = mapMetricsAggregatedData.Get(key);;
_context.MetricItems.Add(metricItem);
await _context.SaveChangesAsync();
}
}
return(await _context.MetricItems.ToListAsync());
}
public static void Run(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.level", "info");
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
var config = new ClientConfig();
config.GetNetworkConfig().AddAddress("127.0.0.1");
var client = HazelcastClient.NewHazelcastClient(config);
var map = client.GetMap <string, HazelcastJsonValue>("json-example");
map.Put("item1", new HazelcastJsonValue("{ \"age\": 4 }"));
map.Put("item2", new HazelcastJsonValue("{ \"age\": 20 }"));
var result = map.Values(Predicates.IsLessThan("age", 6));
Console.WriteLine("Retrieved " + result.Count + " values whose age is less than 6.");
Console.WriteLine("Entry is: " + result.First().ToString());
Console.WriteLine("Finished");
client.Shutdown();
}
protected override void ConfigureClient(ClientConfig config)
{
base.ConfigureClient(config);
config.GetNetworkConfig().SetSmartRouting(false);
}
protected override void ConfigureClient(ClientConfig config)
{
base.ConfigureClient(config);
config.GetNetworkConfig().SetSmartRouting(false);
}
protected virtual void ConfigureClient(ClientConfig config)
{
config.GetNetworkConfig().AddAddress("localhost:5701");
config.GetNetworkConfig().SetConnectionAttemptLimit(20);
config.GetNetworkConfig().SetConnectionAttemptPeriod(2000);
}
private ClientInvocationService CreateInvocationService()
{
return(_config.GetNetworkConfig().IsSmartRouting()
? (ClientInvocationService) new ClientSmartInvocationService(this)
: new ClientNonSmartInvocationService(this));
}
static void Main(string[] args)
{
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("127.0.0.1");
//clientConfig.GetNetworkConfig().AddAddress("10.0.0.2:5702");
//Portable Serialization setup up for Customer CLass
clientConfig.GetSerializationConfig().AddPortableFactory(MyPortableFactory.FactoryId, new MyPortableFactory());
IHazelcastInstance client = HazelcastClient.NewHazelcastClient(clientConfig);
//All cluster operations that you can do with ordinary HazelcastInstance
IMap<string, Customer> mapCustomers = client.GetMap<string, Customer>("customers");
mapCustomers.Put("1", new Customer("Joe", "Smith"));
mapCustomers.Put("2", new Customer("Ali", "Selam"));
mapCustomers.Put("3", new Customer("Avi", "Noyan"));
Customer customer1 = mapCustomers.Get("1");
Console.WriteLine(customer1);
//ICollection<Customer> customers = mapCustomers.Values();
//foreach (var customer in customers)
//{
// //customer
//}
HazelcastClient.ShutdownAll();
Console.ReadKey();
}
private static void Main(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
Environment.SetEnvironmentVariable("hazelcast.client.request.timeout", "250000");
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("192.168.2.50:5701");
clientConfig.GetNetworkConfig().SetConnectionAttemptLimit(1000);
hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
Console.WriteLine("Client Ready to go");
stats = new Stats();
//Thread.Sleep(100000);
if (args != null && args.Length > 0)
{
foreach (var _arg in args)
{
var arg = _arg.Trim();
//if (arg.startsWith("t")) {
// THREAD_COUNT = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("c")) {
// ENTRY_COUNT = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("v")) {
// VALUE_SIZE = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("g")) {
// GET_PERCENTAGE = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("p")) {
// PUT_PERCENTAGE = Integer.parseInt(arg.substring(1));
//}
}
}
else
{
Console.WriteLine("Help: sh test.sh t200 v130 p10 g85 ");
Console.WriteLine(" // means 200 threads, value-size 130 bytes, 10% put, 85% get");
Console.WriteLine("");
}
Console.WriteLine("Starting Test with ");
Console.WriteLine(" Thread Count: " + THREAD_COUNT);
Console.WriteLine(" Entry Count: " + ENTRY_COUNT);
Console.WriteLine(" Value Size: " + VALUE_SIZE);
Console.WriteLine(" Get Percentage: " + GET_PERCENTAGE);
Console.WriteLine(" Put Percentage: " + PUT_PERCENTAGE);
Console.WriteLine(" Remove Percentage: " + (100 - (PUT_PERCENTAGE + GET_PERCENTAGE)));
var tasks = new List <Task>();
for (var i = 0; i < THREAD_COUNT; i++)
{
var t = new Task(() => HzTask(hazelcast), TaskCreationOptions.LongRunning);
tasks.Add(t);
t.Start();
}
var tm = new Thread(StatDisplayTask);
tm.Start();
Task.WaitAll(tasks.ToArray());
tm.Abort();
Console.WriteLine("--THE END--");
//Task.Factory.StartNew(StatDisplayTask);
//startNew.Wait();
//StatDisplayTask();
//Task.Factory.Scheduler.MaximumConcurrencyLevel = THREAD_COUNT;
Console.ReadKey();
}
protected virtual void ConfigureClient(ClientConfig config)
{
config.GetNetworkConfig().AddAddress("127.0.0.1:5701");
config.GetNetworkConfig().SetConnectionAttemptLimit(20);
config.GetNetworkConfig().SetConnectionAttemptPeriod(2000);
}
protected override void ConfigureClient(ClientConfig config)
{
config.GetNetworkConfig().SetRedoOperation(true);
base.ConfigureClient(config);
Environment.SetEnvironmentVariable("hazelcast.client.heartbeat.timeout", "1000");
Environment.SetEnvironmentVariable("hazelcast.client.heartbeat.interval", "1000");
Environment.SetEnvironmentVariable("hazelcast.client.request.retry.count", "25");
Environment.SetEnvironmentVariable("hazelcast.client.request.retry.wait.time", "1000");
}
protected override void ConfigureClient(ClientConfig config)
{
base.ConfigureClient(config);
config.GetNetworkConfig().SetRedoOperation(true);
}
protected override void ConfigureClient(ClientConfig config)
{
config.GetNetworkConfig().SetConnectionAttemptLimit(1);
config.GetNetworkConfig().SetConnectionAttemptPeriod(2000);
}
private IClientInvocationService GetInvocationService(ClientConfig config)
{
return(config.GetNetworkConfig().IsSmartRouting()
? (IClientInvocationService) new ClientSmartInvocationService(this)
: new ClientNonSmartInvocationService(this));
}
static void Main11(string[] args)
{
ClientConfig clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("127.0.0.1");
var hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
var list = hazelcast.GetList<object>("mylist");
list.Add("Item 1");
list.Add("Item 2");
list.Add("Item 3");
Console.WriteLine("count:"+list.Size());
Console.ReadKey();
}
static void Main2(string[] args)
{
ClientConfig clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("192.168.1.162");
var hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
var hzMap = hazelcast.GetMap<string,string>("mylist");
//hzMap.Put("key1","Value1");
//hzMap.Put("key2","Value2");
//hzMap.Put("key3","Value3");
//hzMap.Put("key4","Value4");
Console.WriteLine(hzMap.Get("key1"));
Console.WriteLine(hzMap.Get("key2"));
Console.WriteLine(hzMap.Get("key3"));
Console.WriteLine(hzMap.Get("key4"));
Console.ReadKey();
}
static void Main(string[] args)
{
Environment.SetEnvironmentVariable("hazelcast.logging.type", "console");
Environment.SetEnvironmentVariable("hazelcast.client.request.timeout", "250000");
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("192.168.2.50:5701");
clientConfig.GetNetworkConfig().SetConnectionAttemptLimit(1000);
hazelcast = HazelcastClient.NewHazelcastClient(clientConfig);
Console.WriteLine("Client Ready to go");
stats = new Stats();
//Thread.Sleep(100000);
if (args != null && args.Length > 0)
{
foreach (string _arg in args)
{
string arg = _arg.Trim();
//if (arg.startsWith("t")) {
// THREAD_COUNT = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("c")) {
// ENTRY_COUNT = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("v")) {
// VALUE_SIZE = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("g")) {
// GET_PERCENTAGE = Integer.parseInt(arg.substring(1));
//} else if (arg.startsWith("p")) {
// PUT_PERCENTAGE = Integer.parseInt(arg.substring(1));
//}
}
}
else
{
Console.WriteLine("Help: sh test.sh t200 v130 p10 g85 ");
Console.WriteLine(" // means 200 threads, value-size 130 bytes, 10% put, 85% get");
Console.WriteLine("");
}
Console.WriteLine("Starting Test with ");
Console.WriteLine(" Thread Count: " + THREAD_COUNT);
Console.WriteLine(" Entry Count: " + ENTRY_COUNT);
Console.WriteLine(" Value Size: " + VALUE_SIZE);
Console.WriteLine(" Get Percentage: " + GET_PERCENTAGE);
Console.WriteLine(" Put Percentage: " + PUT_PERCENTAGE);
Console.WriteLine(" Remove Percentage: " + (100 - (PUT_PERCENTAGE + GET_PERCENTAGE)));
var tasks = new List<Task>();
for (int i = 0; i < THREAD_COUNT; i++)
{
var t = new Task(()=> HzTask(hazelcast),TaskCreationOptions.LongRunning);
tasks.Add(t);
t.Start();
}
var tm = new Thread(StatDisplayTask);
tm.Start();
Task.WaitAll(tasks.ToArray());
tm.Abort();
Console.WriteLine("--THE END--");
//Task.Factory.StartNew(StatDisplayTask);
//startNew.Wait();
//StatDisplayTask();
//Task.Factory.Scheduler.MaximumConcurrencyLevel = THREAD_COUNT;
Console.ReadKey();
}
