.NET Edition vs Java Edition (Architecture)
Native Multi-Platform Solution
NCache provides native support for both .NET applications and Java applications. This is done by providing a separate .NET Edition and a Java Edition of NCache. Each edition contains native server-side support for its respective language platform. And, both editions provide the exact same features albeit in their own native language platforms.
Additionally, all the NCache clients (.NET, Java, Node.js, and Python) are able to connect to both editions seamlessly.
.NET Edition
Native solution for .NET applications.
- - Runs in its own .NET CLR process
- - Read-through, Write-through, Write-behind
- - Loader / Refresher
- - Entry Processor
- - .NET Client: 100% C#
- - Java Client: 100% Java
- - Node.js, Python
Platforms:
- - Windows, Linux, macOS
- - Docker, Kubernetes, EKS, GKE, AKS, OpenShift
Java Edition
Native solution for Java applications.
- - Runs in its own JVM process
- - Read-through, Write-through, Write-behind
- - Loader / Refresher
- - Entry Processor (coming soon)
- - Java Client: 100% Java
- - .NET Client: 100% C#
- - Node.js, Python
Platforms:
- - Linux, Windows, macOS
- - Docker, Kubernetes, EKS, GKE, AKS, OpenShift
Server-Side Code (.NET Edition)
NCache architecture is such that all the server-side code in .NET Edition runs in its own separate native .NET CLR process. The "Cache Host Process" on the NCache server (the one hosting the cached data) also runs in a separate process and communicates with this server-side code CLR process through an extremely fast local in-memory RPC using NCache custom Protocol Buffer.
This server-side code includes Read-through, Write-through, Write-behind, Loader, Refresher, and Entry Processor.
Server-Side Code (Java Edition)
NCache architecture is such that all the server-side code in Java Edition runs in its own separate native Java JVM process. The "Cache Host Process" on the NCache server (the one hosting the cached data) also runs in a separate process and communicates with this server-side code JVM process through an extremely fast local in-memory RPC using NCache custom Protocol Buffer.
This server-side code includes Read-through, Write-through, Write-behind, Loader, Refresher, and Entry Processor (coming soon).
Client (.NET)
100% C#
NCache Architecture is such that the .NET client (just like the Java client) is able to talk to both .NET Edition and Java Edition servers. This .NET client opens a socket connection with the NCache servers and directly talks to the cache servers by making RPC calls that use the NCache custom Protocol Buffer. All the data exchanged between the .NET client and NCache servers is serialized either as a binary byte array or JSON.
The .NET client is developed natively in C# as a multi-threaded client and runs on both Windows and Linux.
Client (Java)
100% Java
NCache Architecture is such that the Java client (just like the .NET client) is also able to talk to both Java Edition and .NET Edition servers. This Java client opens a socket connection with the NCache servers and directly talks to the cache servers by making RPC calls that use the NCache custom Protocol Buffer. All the data exchanged between the Java client and NCache servers is serialized either as a binary byte array or JSON.
The Java client is developed natively in Java as a multi-threaded client and runs on both Linux and Windows.
Clients (Node.js, Python)
Both Node.js and Python clients are wrappers on top of the NCache Java client and rely on it to connect and talk to NCache servers.
Node.js and Python clients run on both Linux and Windows.