Comment utiliser la sérialisation compacte
Pourquoi la sérialisation compacte ?
Il s'agit d'un processus de production d'une forme compacte d'objet sérialisé pour l'amélioration des performances, ce qui se traduit par des trajets réseau plus rapides. Comme son nom l'indique, le fichier sérialisé compact est compact sous la forme de données et de processus. L'idée derrière la sérialisation compacte est que chaque 'type connu' (un type connu est un type enregistré avec le framework) se voit attribuer un handle de type unique de 2 octets par le framework, ce qui permet au désérialiseur d'identifier de manière unique les 'types connus' .
Par exemple, supposons que le framework attribue un handle 0 à System.Int32. Ensuite, le sérialiseur écrit le descripteur de 2 octets suivi de 4 octets de valeur d'objet dans le flux. Le désérialiseur lit le handle, détermine le type d'objet, puis crée et remplit l'objet avec sa valeur. D'autre part, la sérialisation native écrit les informations de type complètes avec les données d'objet. NCache ces problèmes de stérilisation native sont résolus de manière sophistiquée de la manière suivante :
- Ici, l'objet sérialisé ne contient pas d'informations de type et d'assemblys complets. Il ne contient qu'une valeur d'objet et un descripteur unique de 2 octets. Ce handle unique de 2 octets est utilisé comme référence pour identifier de manière unique les détails du type lors de la désérialisation d'un objet. De cette façon, la taille de l'objet réduit
- La sérialisation compacte évite également la réflexion, ce qui réduit également les frais généraux
- Les deux fonctionnalités ci-dessus réduisent les opérations d'E/S
- Au fur et à mesure que la taille de l'objet diminue, les déplacements du réseau sont automatiquement plus rapides et, éventuellement, le coût diminue
- La petite taille des objets et le trafic réseau rapide augmentent les performances de l'application
Pour utiliser la sérialisation compacte, vous devez définir un constructeur public par défaut (sans paramètre) dans un type sérialisable compact et enregistrer ce type avec NCache Directeur. NCache prend désormais en charge les types génériques personnalisés. Tous les types génériques avec n'importe quel nombre d'arguments peuvent être sérialisés via une sérialisation compacte. Si un client ne souhaite pas ajouter de types génériques et ses paramètres via l'interface utilisateur, il a la possibilité de les ajouter via la classe IGenericTypes.
Comment utiliser la sérialisation compacte ?
Pour utiliser des types compacts sérialisables avec NCache Configurer le cache avec NCache Manager, puis enregistrez vos types compacts sérialisables avec NCache.
Étape 1 : Enregistrement des types compacts sérialisables :
Vous pouvez enregistrer les types un par un via 'Ajouter des types' bouton. Effectuez les étapes suivantes pour enregistrer vos types avec le cache configuré :
- Arrêtez le cache s'il est en cours d'exécution.
- Cliquez sur le "Sérialisation compacte" onglet qui ouvrira l'écran suivant.
- Cliquez 'Ajouter des types' bouton. UNE 'Sélectionner les classes compactes' la boîte de dialogue apparaîtra.
- Recherchez le fichier d'assemblage contenant les types compacts en cliquant sur l'icône 'Parcourir' bouton comme indiqué sur la figure.
- Sélectionnez les classes que vous souhaitez enregistrer avec le cache dans la liste des classes chargées.
- Presse 'Ajouter une classe' bouton pour ajouter les classes dans la liste des classes sélectionnées.
- Cliquez 'D'accord' .
- Les types nouvellement ajoutés commenceront à apparaître dans la zone de liste sous le "Sérialisation compacte" onglet contenant des informations sur le type compact et la plate-forme.
- 'Supprimer' supprimera le type sélectionné de la liste des types enregistrés.
- Cela montre tous les types ajoutés. Désormais, des arguments peuvent être ajoutés avec des types génériques en sélectionnant un type spécifique, puis en cliquant sur 'Ajouter ' .
Étape 2 : Enregistrement de types compacts génériques via le gestionnaire de type générique
C'est l'autre façon d'enregistrer des types compacts génériques via "Generic Type Handler". Avec Generic Type Handler, l'utilisateur peut ajouter tous les types génériques à la fois en implémentant notre interface. Cela permet d'économiser du temps et des efforts. Voici un exemple de code pour cela.
public class CustomGenericType <T,K,V> { }
public class SetGenerics: IGenericTypeProvider
{
Type[] types = new Type[6];
#region IGenericTypeProvider Members
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;
}
#endregion
}Pour enregistrer les types, suivez ces étapes.
- Cliquez 'Gestionnaire de type générique' bouton. UNE 'Sélectionner les classes compactes' La boîte de dialogue apparaîtra.
- Recherchez le fichier d'assemblage qui implémente cette interface et contient des types compacts en cliquant sur le bouton 'Parcourir' bouton comme indiqué sur la figure.
- Cliquez 'OK' bouton. Tous les types ajoutés seront répertoriés comme indiqué ci-dessous.
