Quelle est la différence entre la sérialisation et le regroupement?

les deux font une chose en commun - qui est sérialiser un objet. La sérialisation est utilisée pour transférer des objets ou pour les stocker. Mais:

• Serialization: lorsque vous sérialisez un objet, seulement les données de membre dans cet objet est écrit au flux de byte; pas le code que en fait implémente l'objet.
• Triage: Terme de Triage est utilisé lorsque nous parlez de passer un objet à des objets distants (RMI) . Dans Marshalling L'objet est sérialisé (les données de membre sont sérialisées) + Codebase est joint.

ainsi la sérialisation fait partie de la formation.

CodeBase est une information qui indique au récepteur de l'Objet où la mise en œuvre de cet objet peut être trouvé. Tout programme qui pense qu'il pourrait jamais passer un objet à un autre programme qui ne l'a peut-être pas vu auparavant doit définir le codebase, de sorte que le récepteur puisse savoir où télécharger le code, s'il n'a pas le code disponible localement. Le récepteur, après avoir désérialisé l'objet, récupérera la base de code et chargera le code à partir de cet endroit.

du Marshalling (computer science) article Wikipedia:

le terme "marshal" est considéré comme synonyme de "serialize" dans la bibliothèque standard de Python 1 , mais les termes ne sont pas synonymes dans la RFC 2713 liée à Java:

À "maréchal" un objet signifie pour enregistrer son état et code(s) d'une telle manière que, lorsque l'mobilisé l'objet est "unmarshalled", une copie de l'objet d'origine est obtenue, éventuellement par le chargement automatique des définitions de classe de l'objet. Vous pouvez agiter n'importe quel objet qui est sérialisable ou distant. Marshalling est comme serialization, sauf marshalling enregistre aussi codebases. Le Marshalling est différent de la sérialisation en ce que le marshalling traite spécialement les objets distants. (RFC 2713)

À "sérialiser" un objet de moyens pour la conversion de son état dans un flux d'octets, de telle manière que le flux d'octets peut être reconvertie en une copie de l'objet.

ainsi, la mise en place de la commande permet également d'enregistrer le code d'un objet dans le flux octet en plus de son état.

je pense que la principale différence est que la mobilisation soi-disant implique également la base de code. En d'autres termes, vous ne seriez pas en mesure de maréchal et unmarshal un objet dans un état équivalent instance d'une autre classe. .

sérialisation signifie simplement que vous pouvez stocker l'objet et réobtenir un État équivalent, même s'il s'agit d'une instance d'une autre classe.

cela dit, ils sont typiquement synonymes.

Marshaling se réfère à la conversion de la signature et de paramètres d'une fonction en un seul tableau d'octets. spécifiquement pour le RPC.

la sérialisation renvoie plus souvent à la conversion d'un arbre objet / objet entier en un tableau d'octets Marshaling va sérialiser les paramètres de l'objet afin de les ajouter au message et le transmettre à travers le réseau. *La sérialisation peut aussi être utilisée pour le stockage sur disque.*

Triage est la règle à dire 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 de caractères représentées comme des types de valeurs différents.

Serialization convertira seulement le contenu de l'objet, pas la représentation (restera le même) et obéira aux règles de serialization, (quoi exporter ou non). Par exemple, privé les valeurs ne seront pas sérialisées, les valeurs publiques oui et la structure de l'objet restera la même.

la mise en ordre est habituellement entre des processus relativement étroitement associés; la sérialisation n'a pas nécessairement cette attente. Ainsi, lorsque vous regroupez des données entre des processus, par exemple, vous pouvez simplement envoyer une référence à des données potentiellement coûteuses à récupérer, alors qu'avec la sérialisation, vous souhaiteriez tout sauvegarder, pour recréer correctement l'objet(les objets) une fois désérialisé.

ma compréhension de la formation est différente des autres réponses.

Sérialisation:

pour produire ou réhydrater une version en format télégraphique d'un graphe objet utilisant une convention.

Triage:

pour produire ou réhydrater une version en format télégraphique d'un graphique d'objet en utilisant un fichier de mappage, de sorte que les résultats peuvent être personnalisés. Le outil peut commencer par adhérer à une convention, mais la différence importante est la capacité de personnaliser les résultats.

Premier Développement Contractuel:

est important dans le contexte du premier développement du contrat.

• il est possible d'apporter des modifications à un graphe objet interne, tout en maintenant l'interface externe stable dans le temps. De cette façon, tous les abonnés du service ne seront pas doit être modifié pour chaque changement trivial.
• il est possible de cartographier les résultats dans différentes langues. Par exemple, de la convention de nom de propriété d'une langue ("property_name") à une autre ("propertyName").

pensez à eux comme des synonymes, les deux ont un producteur qui envoie des choses à un consommateur... Dans les champs de fin des instances sont écrits dans un flux octet et l'autre extrémité oppose l'inverse et les mêmes instances.

NB-java RMI contient également un support pour le transport des classes manquantes du destinataire...

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;
}

dans la sérialisation, les données sont aplaties d'une manière qui peut être stockée et non flattée plus tard.

Rassemblement Démo:

(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 n'ont pas nécessairement besoin d'être aplatie, mais il doit être transformé en une autre représentation alternative. tout le casting est marshaling, mais pas tous marshaling est prépondérante.

Marshaling ne nécessite pas d'allocation dynamique pour être impliqué, il peut aussi tout simplement être la transformation entre les structures. Par exemple, vous pouvez avoir une paire, mais la fonction s'attend à ce que le premier et le deuxième éléments de la paire soient dans l'autre sens; vous casting/memcpy une paire à une autre ne fera pas le travail parce que fst et snd seront renversé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 la formation de groupements devient particulièrement important lorsque vous commencez à traiter avec des unions marquées de plusieurs types. Par exemple, vous trouverez peut-être difficile d'obtenir un moteur JavaScript pour imprimer une "chaîne c" pour vous, mais vous pouvez lui demander d'imprimer un enveloppé de chaîne c pour vous. Ou si vous voulez imprimer une chaîne de caractères à partir de L'exécution JavaScript dans une exécution Lua ou Python. Ce sont toutes des ficelles, mais souvent elles ne s'entendent pas sans se regrouper.

un ennui que j'ai eu récemment était que JScript arrays marshal à C# comme "_ _ ComObject", et n'a aucune façon documentée pour jouer avec cet objet. Je peux trouver l'adresse de l'endroit où il est, mais je ne sais vraiment rien d'autre à ce sujet, donc le seul moyen de vraiment comprendre est de poke à elle de toute façon possible et espérons trouver des informations utiles à ce sujet. Il devient donc plus facile de créer un nouvel objet avec une interface plus conviviale comme Scripting.Dictionnaire, copiez les données de l'objet JScript array dans lui, et passez que object to 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]);

yet Anothertestobject.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);
        }
    }
}

au-dessus des tirages "__ComObject", qui est une sorte de boîte noire du point de vue de C#.

un autre concept intéressant est que vous pourriez avoir la compréhension comment écrire du code, et un ordinateur qui sait exécuter des instructions, de sorte que programmeur, vous êtes effectivement marshaling le concept de ce que vous voulez faire de votre cerveau vers le programme de l'image. Si nous avions assez de bons marshallers, nous pourrions juste penser à ce que nous voulons faire/changer, et le programme changerait de cette façon sans taper sur le clavier. Donc, si vous pouviez avoir un moyen de stocker tous les changements physiques dans le cerveau pour les quelques secondes où vous voulez vraiment écrire un point-virgule, vous pourriez maréchal que les données en un signal pour imprimer un point-virgule, mais c'est extrême.

Marshaling utilise le processus de sérialisation en fait, mais la différence majeure est que dans la sérialisation seuls les membres de données et l'objet lui-même sont sérialisés pas les signatures mais dans la base de code objet + (son implémentation) sera également transformé en octets.

Marshalling est le processus pour convertir un objet java en objets xml en utilisant JAXB afin qu'il puisse être utilisé dans les services web.