Simple In-Memory Caching in .Net with Apache Ignite

-

 In the Last Post we have seen how to setup Apache Ignite Server as an independent process . Now we will see how to use the Apache Ignite as an In-Memory Cache in .NET. We will see through an example how to write Clients which knows how to talk with the Apache Ignite Server.

Installing Necessary Nuget Packages

Before starting off we have to install Apache.Ignite NuGet package to the Console Application that we have created which is required to enable Apache Ignite functionality. This can be installed through Visual studio "Manage NuGet Packages" tool.

Once the NuGet package is installed for the project we have to write clients which can access the Apache Ignite cache store to "Put" and "Get" data. Basically Apache Ignite will store the data as Key Value Pair. Code to access the cache from the client is shown below:

Code


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using Apache.Ignite.Core;
using Apache.Ignite.Core.Client;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InMemeoryCache
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var cfg = new IgniteClientConfiguration
            {
                Endpoints = new[] { "127.0.0.1:10800"}
            };

            using (var client = Ignition.StartClient(cfg))
            {
                var cache = client.GetOrCreateCache<int, string>("MyCache");
                if(cache.ContainsKey(1))
                {
                    Console.WriteLine($"Cache Contains {cache.Get(1)}");
                }
                else
                {
                    cache.Put(1, "One");
                    Console.WriteLine($"Inserting into Cache");
                }
            }

            Console.ReadKey();
        }
    }
}


Before starting the client we have to start the Apache Ignite Server by clicking on the Ignite.bat file which can be found in the Ignite install path\bin folder. Please note that we can also start the Ignite Server from the code using Ignition.Start() API. Ignite Server listens on the default port number 10800.

Once the Server is successfully started we can run the client application. If we run the client application for the first time we can see that the cache will be empty and the else case will be executed where we will put the data in the cache. Output will be as shown below:

Inserting into Out of Proc Ignite Cache



Once client execution completes we have already pushed the data into Ignite. Then if we execute the client once again we can see that the if condition will be true and the data is retrieved from the cache. Output will be as shown below:



Fetching Details from the Cache





Comments

Post a Comment

Popular posts from this blog

Step By Step Guide to Detect Heap Corruption in Windows Easily

-
Image
Introduction Heap memory corruption is a critical issue that can lead to application crashes, data loss, and even security vulnerabilities. Detecting and addressing heap memory corruption early is crucial for maintaining the stability and security of Windows applications. In this blog post, we will explore how to detect heap memory corruption using two powerful tools: DebugDiag and AppVerifier. Must Read : synchronization in C++20 . Understanding Heap Memory Corruption Heap memory is a dynamically allocated memory space used by applications to store data at runtime. Heap memory corruption occurs when an application writes data beyond the allocated memory boundaries , leading to memory leaks, crashes, and unpredictable behavior. Detecting such corruption manually can be time-consuming and complex, making automated tools invaluable for identifying and diagnosing these issues. What is PageHeap? PageHeap specifically focuses on detecting heap-related problems, like heap overflows, heap und...
Read more

How to dynamically add Properties in C# .NET?

-
Image
There are certain situations where we have to create object dynamically with properties added to the object dynamically. Data related to these properties may be coming in from external sources like a file or from any other serialized format. We can achieve this with the help of reflection, but it is bit complex and should have some prior knowledge of Reflection. What is meant by Dynamic Creation of Properties in c#? Dynamic creation of properties means at the time of writing the code, programmer is not aware of the properties which can be part of the object and its value. For Example there may be some data which needs to be read from say xml file, In this case there should be some organized way by which we can represent the data, This can be in the form of a object. Content of this object and the properties cannot be deduced while writing the application, it needs to be constructed from the xml file which is read when the application runs. Expando Object Expando Object comes to the res...
Read more

How To Visualize Clustered and Unclustered Index In SQL

-
Working with SQL databases forces you to come across primarily the clustered and the unclustered indexes. These are handy features that if used wisely can greatly enhance the speed of execution of the listed queries. But it can be hard to grasp their fundamentals, especially if you want to picture it in your head. In this blog post, I explain what clustered and unclustered indexes are, why they are of importance and most important how they can be explained without the necessity of explaining all the details. What is a Clustered Index? A clustered index specifies how the data stored in a table is sorted out in relation to the other fields in that table. Let’s consider, as an example, a to-do list that you create and find that it has automatically been arranged in a certain order. When you apply a clustered index on a unique key The control column such as SQL Server will automatically add rows of that table in accordance with the control column. Since the book-placement is done acc...
Read more