Implémentation de la sérialisation compacte dynamique
NCache stocke les données d'application sous forme sérialisée - elles sont sérialisées sur le client de cache avant d'être ajoutées au cache. Par conséquent, les données que vous ajoutez au cache doivent également être marquées comme sérialisables. Il prend en charge la sérialisation binaire native et les informations JSON ne circulent pas sur le réseau et la taille des objets sur le réseau est réduite. À mesure que la taille de l'objet diminue, les déplacements réseau deviennent plus rapides et, à terme, le coût diminue, augmentant ainsi les performances globales de l'application.
La sérialisation compacte est également une sérialisation binaire qui présente les avantages suivants :
Taille de données compacte
In NCache données binaires, la taille de l'objet sérialisé est compacte. Dans certains scénarios, la taille des données peut être 10 fois inférieure à celle de la sérialisation native. Les objets sérialisés plus petits mettent ainsi moins de temps à voyager sur le réseau, ce qui entraîne un débit plus élevé. Cela contribue également à réduire la consommation de mémoire sur le serveur de cache. De cette façon, NCache permet d'obtenir de meilleures performances, réduisant ainsi le temps et les coûts. La petite taille des objets et le trafic réseau rapide augmentent les performances des applications.
Plus rapide que la sérialisation native
La sérialisation compacte est plus rapide que la sérialisation native, car elle ne repose pas autant sur la réflexion que la sérialisation native. La sérialisation native utilise la réflexion pour les informations d'attribut. Cette réflexion est évitée dans NCachela sérialisation compacte de . Les informations de type pour les types compacts ne sont chargées qu'une seule fois lorsque le cache est initialisé, ce qui réduit la surcharge liée à l'utilisation de la sérialisation native. Des benchmarks ont montré que dans certains cas d'utilisation, cette méthode est 5 à 10 fois plus rapide que la sérialisation native.
Aucun changement de code
Aucune modification de code n’est requise pour rendre une classe compacte sérialisable. La seule étape requise est de configurer vos classes via des outils de gestion (le NCache Management Center ou ses outils de ligne de commande).
Sérialisation sélective : NCache permet une sérialisation sélective ; vous pouvez sélectionner les données membres d'une classe que vous souhaitez marquer comme non sérialisables. L'attribut exclu de tout objet mis en cache sera nul ou aura une valeur par défaut (s'il est attribué). Cette fonctionnalité est utile dans un scénario dans lequel, pour certains attributs, il n'est pas nécessaire de mettre en cache, par exemple l'objet de connexion pour la base de données. Grâce à cette sérialisation sélective, le processus devient encore plus efficace et plus compact.
Contrôle granulaire sur la sérialisation compacte : Pour cela, vous pouvez implémenter
ICompactSerializable
. Cette interface vous offre un contrôle plus précis sur la sérialisation compacte, vous pouvez contrôler quels membres de données sérialiser et lesquels exclure en fonction des besoins de votre entreprise.Prise en charge de la sérialisation native : NCache prend en charge la sérialisation binaire native. Les données sont stockées sous forme sérialisée dans le cache, la sérialisation native du client est prise en charge pour les clients .NET et Java de NCache.
Implémentation de la sérialisation compacte pour le type d'objet
Pour utiliser la sérialisation compacte, les types d'objets qui doivent être sérialisés de manière compacte doivent être configurés via le NCache Centre de gestion. NCache gère en interne la sérialisation/désérialisation des classes enregistrées et l'utilisateur n'a pas besoin de coder explicitement pour cela.
Important
Les attributs de classe doivent être désérialisés dans le même ordre dans lequel ils ont été sérialisés, sinon le flux sérialisé ne peut pas être désérialisé.
Toutefois, NCache permet également la mise en œuvre explicite du ICompactSerializable
interface.
Pour implémenter cette interface, la classe DemoObject doit implémenter Serialize
ainsi que le Deserialize
méthodes qui seront appelées par NCache lors de la sérialisation/désérialisation de cet objet. Un exemple de code pour implémenter cette interface est donné ci-dessous :
Important
Si vous souhaitez marquer une classe pour une sérialisation compacte qui nécessite un constructeur paramétré, assurez-vous que la classe contient un constructeur par défaut.
Pré-requis
- Pour en savoir plus sur les prérequis standard requis pour travailler avec tous NCache fonctionnalités côté serveur, veuillez vous référer à la page donnée sur Prérequis de l'API côté serveur.
- Le cache doit être en cours d'exécution.
- La demande doit être connecté au cache avant d'effectuer l'opération.
- Pour plus de détails sur l'API, reportez-vous à : ICompactSérialisable, Sérialiser, Désérialiser, CheckIfSérialisable, IGenericTypeProvider.
Création d'un objet de démonstration
public class DemoObject : ICompactSerializable
{
private string _attribute1;
private int _attribute2;
private bool _attribute3;
public DemoObject()
{ }
public DemoObject(string attrib1, int attrib2, bool attrib3)
{
_attribute1 = attrib1;
_attribute2 = attrib2;
_attribute3 = attrib3;
}
#region ICompactSerializable Members
public void Deserialize(CompactReader reader) {
_attribute1 = reader.ReadObject() as string;
_attribute2 = reader.ReadInt32();
_attribute3 = reader.ReadBoolean();
}
public void Serialize(CompactWriter writer){
writer.WriteObject(_attribute1);
writer.Write(_attribute2);
writer.Write(_attribute3);
}
#endregion
}
Implémentation d'un gestionnaire de type générique
NCache permet également d'enregistrer des types génériques dans la sérialisation compacte. Pour cela, chaque type doit être enregistré via le NCache Centre de gestion. Il existe un autre moyen d'enregistrer des types compacts génériques via le "Generic Type Handler". Avec le gestionnaire de types génériques, l'utilisateur peut ajouter tous les types génériques à la fois, en implémentant le IGenericTypeProvider
interface. Cela permet d'économiser beaucoup de temps et d'efforts au cas où l'utilisateur souhaite enregistrer un grand nombre de types.
Important
Pour utiliser l'interface, incluez l'espace de noms suivant dans votre application : Alachisoft.NCache.Runtime.GenericTypesProvider
Pour implémenter cela, l'utilisateur doit implémenter le GetGenericTypes
méthode et renvoie les types génériques souhaités dans le Type
tableau. Après cela, déployez cet assembly de classe sur le NCache Centre de gestionL’ NCache Le Centre de gestion enregistrera tous les types renseignés dans le Type
tableau. Un exemple de code est donné ci-dessous :
Important
Si vous souhaitez marquer une classe pour une sérialisation compacte qui nécessite un constructeur paramétré, assurez-vous que la classe contient un constructeur par défaut.
public class CustomGenericType<T, K, V>
{ }
public class SetGenerics : IGenericTypeProvider
{
Type[] types = new Type[6];
Type[] IGenericTypeProvider.GetGenericTypes()
{
types[0] = typeof(Dictionary<string, Customer>);
types[1] = typeof(List<int>);
types[2] = typeof(CustomGenericType<Employee, Product, Customer>);
types[3] = typeof(CustomGenericType<Employee, Product, int>);
types[4] = typeof(CustomGenericType<Employee, string, byte>);
types[5] = typeof(CustomGenericType<string, Customer, bool>);
return types;
}
public bool CheckIfSerializable(Type type, FieldInfo fieldInfo)
{
// Implement logic
}
}
Dépannage
Exception de sérialisation compacte
Une exception de sérialisation peut se produire sur le nœud où les types compacts sérialisables ne sont pas enregistrés.
Solution
Registre Compact Sérialisable types sur tous les nœuds du cluster.
Voir aussi
.RAPPORTER: Alachisoft.NCache.Durée espace de noms.