Quelle est la différence entre la sérialisation et Marshaling?
Je sais qu'en termes de plusieurs techniques distribuées (telles que RPC), le terme "Marshaling" est utilisé, mais je ne comprends pas en quoi il diffère de la sérialisation. Ne sont-ils pas tous deux en train de transformer des objets en une suite de bits?
Apparenté, relié, connexe:
Marshaling et sérialisation sont vaguement synonymes dans le contexte d'un appel de procédure à distance, mais sémantiquement différents sur le plan de l'intention.
En particulier, le marshaling consiste à obtenir des paramètres d'ici là, tandis que la sérialisation consiste à copier des données structurées vers ou à partir d'une forme primitive telle qu'un flux d'octets. En ce sens, la sérialisation est un moyen d'effectuer le marshaling, généralement en implémentant une sémantique passage par valeur.
Il est également possible qu'un objet soit marshalé par référence, auquel cas les données "sur le fil" sont simplement des informations de localisation pour l'objet d'origine. Toutefois, un tel objet peut toujours faire l'objet d'une sérialisation de valeur.
Comme @Bill le mentionne, il peut y avoir des métadonnées supplémentaires telles que l'emplacement de la base de code ou même le code d'implémentation d'objet.
Les deux font une chose en commun: il s'agit de la sérialisation d'un objet. La sérialisation est utilisée pour transférer des objets ou pour les stocker. Mais:
- Sérialisation: Lorsque vous sérialisez un objet, seules les données membres de cet objet sont écrites dans le flux d'octets. pas le code qui implémente réellement l'objet.
- Marshalling: Le terme Marshalling est utilisé quand on parle de passage d'objet à des objets distants (RMI). Dans Marshalling, l'objet est sérialisé (les données de membre sont sérialisées) + Codebase est attaché.
La sérialisation fait donc partie du Marshalling.
CodeBase est une information qui indique au destinataire de Object où se trouve la mise en oeuvre de cet objet. Tout programme qui pense pouvoir éventuellement transmettre un objet à un autre programme qui ne l’a jamais vu auparavant doit définir la base de code afin que le destinataire sache où télécharger le code, s’il n’a pas le code disponible localement. Lors de la désérialisation de l'objet, le destinataire en extrait le code et charge le code à partir de cet emplacement.
Extrait du Marshalling (informatique) Article Wikipedia:
Le terme "marshal" est considéré comme synonyme de "sérialiser" dans la bibliothèque standard Python 1 , mais les termes ne sont pas synonymes dans le RFC 2713 relatif à Java:
"Marcher" un objet signifie enregistrer son état et sa (ses) base (s) de code de manière à obtenir une copie de l’objet original lorsque celui-ci est "incontrôlé", éventuellement en chargeant automatiquement ses définitions de classe. Vous pouvez organiser tout objet sérialisable ou distant. Le marshalling ressemble à la sérialisation, sauf que le marshalling enregistre également les bases de code. Le marshalling est différent de la sérialisation en ce sens qu'il traite spécialement les objets distants. (RFC 2713)
"Sérialiser" un objet signifie convertir son état en un flux d'octets de manière à ce que le flux d'octets puisse être reconverti en une copie de l'objet.
Ainsi, le marshalling enregistre également la base de code d'un objet du flux d'octets, en plus de son état.
Je pense que la principale différence est que Marshalling est supposé impliquer également le code de base. En d'autres termes, vous ne seriez pas en mesure de structurer et de disséminer un objet dans une instance équivalente à l'état d'une classe différente. .
La sérialisation signifie simplement que vous pouvez stocker l'objet et retrouver un état équivalent, même s'il s'agit d'une instance d'une autre classe.
Cela étant dit, ils sont généralement synonymes.
Marshaling fait référence à la conversion de la signature et des paramètres d'une fonction en un tableau à un seul octet. Spécifiquement dans le but de RPC.
La sérialisation fait plus souvent référence à la conversion d'un arbre objet/objet entier en un tableau d'octets Marshaling va sérialiser les paramètres d'objet afin de les ajouter au message et de les transmettre réseau. * La sérialisation peut également être utilisée pour le stockage sur disque. *
Marshalling est la règle pour indiquer au compilateur comment les données seront représentées sur un autre environnement/système; Par exemple;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
public string cFileName;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
public string cAlternateFileName;
comme vous pouvez voir deux valeurs de chaîne différentes représentées par différents types de valeur.
Sérialisation convertira uniquement le contenu de l'objet, pas la représentation (restera identique) et obéira aux règles de la sérialisation (que exporter ou non). Par exemple, les valeurs privées ne seront pas sérialisées, les valeurs publiques oui et la structure d'objet restera la même.
Voici des exemples plus spécifiques des deux:
Exemple de sérialisation:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
typedef struct {
char value[11];
} SerializedInt32;
SerializedInt32 SerializeInt32(int32_t x)
{
SerializedInt32 result;
itoa(x, result.value, 10);
return result;
}
int32_t DeserializeInt32(SerializedInt32 x)
{
int32_t result;
result = atoi(x.value);
return result;
}
int main(int argc, char **argv)
{
int x;
SerializedInt32 data;
int32_t result;
x = -268435455;
data = SerializeInt32(x);
result = DeserializeInt32(data);
printf("x = %s.\n", data.value);
return result;
}
Lors de la sérialisation, les données sont aplaties de manière à pouvoir être stockées et non aplaties ultérieurement.
Démonstration de Marshalling:
(MarshalDemoLib.cpp)
#include <iostream>
#include <string>
extern "C"
__declspec(dllexport)
void *StdCoutStdString(void *s)
{
std::string *str = (std::string *)s;
std::cout << *str;
}
extern "C"
__declspec(dllexport)
void *MarshalCStringToStdString(char *s)
{
std::string *str(new std::string(s));
std::cout << "string was successfully constructed.\n";
return str;
}
extern "C"
__declspec(dllexport)
void DestroyStdString(void *s)
{
std::string *str((std::string *)s);
delete str;
std::cout << "string was successfully destroyed.\n";
}
(MarshalDemo.c)
#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
int main(int argc, char **argv)
{
void *myStdString;
LoadLibrary("MarshalDemoLib");
myStdString = ((void *(*)(char *))GetProcAddress (
GetModuleHandleA("MarshalDemoLib"),
"MarshalCStringToStdString"
))("Hello, World!\n");
((void (*)(void *))GetProcAddress (
GetModuleHandleA("MarshalDemoLib"),
"StdCoutStdString"
))(myStdString);
((void (*)(void *))GetProcAddress (
GetModuleHandleA("MarshalDemoLib"),
"DestroyStdString"
))(myStdString);
}
Dans le marshaling, les données ne doivent pas nécessairement être aplaties, mais doivent être transformées en une autre représentation. tout le casting est marshaling, mais pas tout le marshaling est casting.
Marshaling ne nécessite pas d'allocation dynamique, il peut aussi s'agir simplement d'une transformation entre structures. Par exemple, vous pouvez avoir une paire, mais la fonction s'attend à ce que les premier et second éléments de la paire soient inversés; vous ne faites pas le travail de fondre/mémoriser une paire sur une autre, car fst et snd seront inversés.
#include <stdio.h>
typedef struct {
int fst;
int snd;
} pair1;
typedef struct {
int snd;
int fst;
} pair2;
void pair2_dump(pair2 p)
{
printf("%d %d\n", p.fst, p.snd);
}
pair2 marshal_pair1_to_pair2(pair1 p)
{
pair2 result;
result.fst = p.fst;
result.snd = p.snd;
return result;
}
pair1 given = {3, 7};
int main(int argc, char **argv)
{
pair2_dump(marshal_pair1_to_pair2(given));
return 0;
}
Le concept de marshaling devient particulièrement important lorsque vous commencez à traiter avec des unions marquées de nombreux types. Par exemple, vous pourriez avoir du mal à faire en sorte qu'un moteur JavaScript imprime une "chaîne c" pour vous, mais vous pouvez lui demander d'imprimer une chaîne c enveloppée pour vous. Ou si vous souhaitez imprimer une chaîne à partir du runtime JavaScript dans un runtime Lua ou Python. Ils sont tous des chaînes, mais souvent ne s'entendront pas sans marshaling.
Un problème que j’ai eu récemment est que les tableaux JScript sont marshalés en C # en tant que "__ComObject" et n’ont aucun moyen documenté de jouer avec cet objet. Je peux trouver l'adresse de l'endroit où il se trouve, mais je ne sais vraiment rien d'autre à ce sujet. Le seul moyen de le savoir est de le fouiller de toutes les manières possibles et, espérons-le, de trouver des informations utiles. Il devient donc plus facile de créer un nouvel objet avec une interface plus conviviale telle que Scripting.Dictionary, d'y copier les données de l'objet tableau JScript et de le transmettre à C # au lieu du tableau par défaut de JScript.
test.js:
var x = new ActiveXObject("Dmitry.YetAnotherTestObject.YetAnotherTestObject");
x.send([1, 2, 3, 4]);
YetAnotherTestObject.cs
using System;
using System.Runtime.InteropServices;
namespace Dmitry.YetAnotherTestObject
{
[Guid("C612BD9B-74E0-4176-AAB8-C53EB24C2B29"), ComVisible(true)]
public class YetAnotherTestObject
{
public void send(object x)
{
System.Console.WriteLine(x.GetType().Name);
}
}
}
ci-dessus affiche "__ComObject", qui est en quelque sorte une boîte noire du point de vue de C #.
Un autre concept intéressant est que vous savez peut-être comment écrire du code et un ordinateur qui sait exécuter des instructions. Ainsi, en tant que programmeur, vous articulez efficacement le concept de ce que vous voulez que l'ordinateur fasse de votre cerveau au programme. image. Si nous avions suffisamment de bons contrôleurs, nous pourrions simplement penser à ce que nous voulons faire/changer, et le programme changerait de cette façon sans avoir à taper sur le clavier. Donc, si vous pouviez avoir un moyen de stocker tous les changements physiques dans votre cerveau pendant les quelques secondes où vous voulez vraiment écrire un point-virgule, vous pourriez regrouper ces données dans un signal permettant d'imprimer un point-virgule, mais c'est une extrême.
Le Marshalling se situe généralement entre des processus relativement étroitement associés; la sérialisation n'a pas nécessairement cette attente. Ainsi, lorsque vous organisez des données entre des processus, par exemple, vous voudrez peut-être simplement envoyer une référence à des données potentiellement coûteuses à récupérer, tandis qu'avec la sérialisation, vous souhaiterez tout sauvegarder pour recréer correctement le ou les objets lors de la désérialisation.
Ma compréhension du tri est différente des autres réponses.
Sérialisation:
Produire ou réhydrater une version au format fil d'un graphe d'objet en utilisant une convention.
Marshalling:
Produire ou réhydrater une version au format fil d'un graphe d'objet en utilisant un fichier de mappage, afin que les résultats puissent être personnalisés. L'outil peut commencer par adhérer à une convention, mais la différence importante réside dans la possibilité de personnaliser les résultats.
premier contrat de développement:
Le Marshalling est important dans le contexte du développement du premier contrat.
- Il est possible d'apporter des modifications à un graphe d'objet interne, tout en maintenant la stabilité de l'interface externe dans le temps. De cette façon, tous les abonnés au service n'auront pas à être modifiés pour chaque changement trivial.
- Il est possible de mapper les résultats dans différentes langues. Par exemple, de la convention de nom de propriété d'une langue ('nom_propriété') à une autre ('nomPropriété').
Marshaling utilise en réalité le processus de sérialisation, mais la différence majeure réside dans le fait qu’en série, seuls les membres de données et l’objet lui-même sont sérialisés, mais en Marshalling, l’objet Marshalling + la base de code (son implémentation) sont également transformés en octets.
Le marshalling est le processus permettant de convertir un objet Java en objets xml à l'aide de JAXB, de sorte qu'il puisse être utilisé dans des services Web.
Considérez-les comme des synonymes: les deux producteurs ont un producteur qui envoie des éléments à un consommateur ... À la fin, les champs d'instances sont écrits dans un flux d'octets et l'autre extrémité s'oppose à l'inverse et avec les mêmes instances.
NB - Java RMI prend également en charge le transport des classes manquantes chez le destinataire ...