For a comprehensive list of ALL FEATURES in NCache, please read NCache Features:
Support for Data Encryption
Encryption feature is provided to make sure that data traveling between NCache client and NCache server or between cluster nodes is encrypted. This will prevent the user data leakage even if data packets are sniffed from the network.
Runtime Data Sharing between .NET & Java
NCache now allows you to store either .NET objects in the cache and read them as Java objects from your Java applications, or vice versa. And, instead of doing .NET to Java transformation through XML, NCache uses binary-level transformation. As a result, the performance is super fast. NCache automatically resolves type conflicts between Java and .NET.
You can also utilize multiple versions in Runtime Data Sharing between .NET and Java. See details below.
Multiple Objects Version Support (.NET & Java)
You can now share multiple versions of the same .NET or Java classes across multiple applications. One application may be using version 1.0 of a class while another application may have a later version 2.0 of this same class. When version 2.0 of this class is stored in the cache, the earlier application can still fetch this class as version 1.0, and vice versa. NCache lets you configure version mappings through XML configuration files.
You can utilize version also in Runtime Data Sharing between .NET and Java.
Continuous Query (.NET & Java)
NCache lets you specify a data-set based on an SQL-like query. It then maintains this data-set in the cache cluster for you and monitors any runtime changes in it, including additions, updates, or deletes. And, NCache notifies your application whenever any of these changes occur in the dataset. This allows your applications to more intelligently monitor for either data changes or addition of data matching a certain criteria and be notified by NCache.
This is a powerful feature if you want to share data at runtime between multiple applications.
Much Enhanced Bridge Topology
Bridge Topology allows you to intelligently and asynchronously replicate the entire cache across the WAN. NCache 4.1 now offer four different configurations in Bridge Topology. They are:
Active/Passive: In this configuration, one cache is active and the other passive. Whatever updates you make to the active cache are asynchronously applied to the passive cache by the Bridge. Since the connection between active and passive is across the WAN, it is likely to be unstable. But, the Bridge is aware of it and if the connection breaks, it automatically reestablishes it.
Active/Active: In this configuration, both caches are active and the Bridge receives update requests from both sides. Both caches are also maintaining an identical "clock" for time-stamping. This clock is synchronized through the Bridge. Whenever there is a conflict, meaning the same cache item is being updated in both caches, it is resolved by default on a last-update-wins strategy. But, if you want, you can provide a custom resolution handler which is invoked in case of a conflict. You can then determine which update should stay and which one should be discarded.
Hub-Spoke: In this configuration, there is one active Hub and multiple passive Spokes (or satellite caches). All updates originate from the Hub and are asynchronously applied to all the Spokes. The Spokes are always read-only.
Star: This configuration looks identical to a Hub-Spoke except that all the Spokes are also active. In this configuration, there is one centralized cache and multiple satellite active caches. All updates are synchronized through the centralized cache to ensure consistency.
Named Tags (.NET & Java)
Previously, you could only assign tags as values. Now, you can assign tags with names. This allows you to index data based on attribute name and attribute value concept. Previously, you could index objects but all string data could not be indexed. Now, even string data (e.g. XML) could be indexed with named tags. Then, you could either use NCache API to fetch data belonging to one or more named tags or you could issue SQL-like query (through LINQ or OQL) for it.
Java Features Now 100% Equivalent to .NET
NCache brings support for Java at the same level as .NET. Here are the new Java based features intended to catch up to .NET feature-set:
Java Client API 100% equivalent to .NET
Java Client Cache (InProc): You can now use Client Cache feature in Java applications on Windows or Unix. There is no code change required in your applications to enable Client Cache.
Read-Thru, Write-Thru, Write-Behind in Java: You can now write your Read-Thru and Write-Thru handlers in Java and register them with NCache. NCache runs your native Java code on the cache servers just like it does with .NET code.
Cache Loader in Java: Write your cache loading code in Java and register it with NCache. Your native Java code will run on cache servers just like the .NET code.
Dynamic Compact Serialization for Java: Now, you can register your Java classes with NCache and NCache generates their serialization code at initialization time, compiles it in-memory, and sends it to NCache clients. This compiled Java code is then run to serialize/de-serialize your Java classes. This obviously speeds up your performance because compiled serialization code runs much faster than Reflection based serialization that is otherwise done in Java.
Spring/Hibernate Support: NCache now provides an L2 Cache for Hibernate. This allows you to start using NCache without making any code changes in your Java application.