JSON è un formato per l’interscambio dei dati tra applicazioni client-server,

in C# possiamo utilizzare:

Json.Encode()
Json.Decode()

che troviamo nel namespace System.Web.Helpers

Con queste due funzioni possiamo rispettivamente serializzare e deserializzare un qualsiasi oggetto C# da e verso JSON.
La serializzazione standard prevede la creazione di stringhe JSON in forma di coppie chiave-valore.

Ad esempio, immaginiamo di avere la seguente classe C# che memorizza lo stato di gioco corrente in un ambiente multiplayer (ad esempio da dover inviare a tutti i client connessi ogni tot millisecondi):

private class GameSnapshot
{
            public class EnemyPosition
            {
                public double x;
                public double y;
                public double direction;
                public int energy;
            }

            public string playerName;
            public double playerXpos;
            public double playerYpos;
            public int lives;
            public int level;
            public int points;
            public List<EnemyPosition> enemiesPositions;
            public DateTime timestamp;
}

La lista enemiesPositions contiene le posizioni degli avversari, gli altri parametri sono quelli relativi al giocatore (posizione, stato, vite rimanenti etc..).
Una plausible conversione JSON dell’oggetto potrebbe essere la seguente:

{
  "playerName": "unnamed player",
  "playerXpos": 12.124354328,
  "playerYpos": 3.8943532434,
  "lives": 4,
  "level": 12,
  "points": 81000,
  "enemiesPositions": [
    {
      "x": 0.17568866497636246,
      "y": 0.8758737812172034,
      "direction": 0.5097326890145115,
      "energy": 1102696000
    },
    {
      "x": 0.26358662371690694,
      "y": 0.8292919941382911,
      "direction": 0.26260223484719275,
      "energy": 2123401755
    },
    {
      "x": 0.7504166782602746,
      "y": 0.5961088224296034,
      "direction": 0.5173756976227163,
      "energy": 1782593816
    },
    {
      "x": 0.4766914893298836,
      "y": 0.8596706198806272,
      "direction": 0.1079285652879293,
      "energy": 1907324897
    },
    {
      "x": 0.5031359705622941,
      "y": 0.13449626934458328,
      "direction": 0.21105524069213086,
      "energy": 1125504690
    }
  ],
  "timestamp": "/Date(1437732572430)/"
}

Per un totale di 923 byte, quasi 1K di dati da trasmettere. Non molti, ma dobbiamo considerare che i dati potrebbero dover essere trasmessi molte volte al secondo e che i client connessi potrebbero essere molti.

Di default la serializzazione prevede la creazione di coppie chiavi-valore dove chiave è il nome della variabile (es. “playerName”) e valore il suo valore corrispondente (es. “unnamed player”). Per una codifica più efficiente possiamo eliminare tutte le chiavi e lasciare solo i valori: la posizione relativa dei valori nella struttura dati JSON è sufficiente a ricostruire completamente (deserializzare) l’oggetto originale.

A tal fine possiam utilizzare il tipo dati dynamic, introdotto in C# 4.0. Dynamic è un tipo dati appunto dinamico, il compilatore ignora il tipo reale della variabile o lo pospone all’esecuzione. Creando una lista di dynamic possiamo creare sequenze di oggetti non omogenei tra loro (liste o array di tipi diversi) ognuno dei quali è anche anomimo (non ha un nome esplicito, è solo un elemento della lista).

La classe di prima diventa semplicemente una lista di tipi dynamic:

var gameShapshot = new List<dynamic>();

Possiamo aggiungere a questa lista (metodo .Add()) qualsiasi oggetto: un int, una striga, un DateTime, liste di altri oggetti e cosi’ via. Ad esempio, possiamo creare un oggetto dynamic che contiene le stesse informazioni della classe GameSnapshot vista in precedenza.

var gs = new List<dynamic>();

gs.Add("unnamed player");
gs.Add(12);
gs.Add(4);
gs.Add(81000);
gs.Add(DateTime.Now);
gs.Add(12.124354328);
gs.Add(3.8943532434);
var enemiesPositions = new List<dynamic>();

for (var i = 0; i < 5; i++)
{
   var enemyPos = new List<dynamic>();
   enemyPos.Add(rnd.NextDouble());
   enemyPos.Add(rnd.NextDouble());
   enemyPos.Add(rnd.NextDouble());
   enemyPos.Add(rnd.Next());

   enemiesPositions.Add(enemyPos);
}
gs.Add(enemiesPositions);

String snapShot = Json.Encode(gs);
System.Console.WriteLine(snapShot);

Abbiamo ora un oggetto C# che contiene le stesse informazioni (sia in valore che in struttura) ma la serializzazione JSON risulta molto più snella:

[
  "unnamed player",
  12,
  4,
  81000,
  "/Date(1437732515952)/",
  12.124354328,
  3.8943532434,
  [
    [
      0.5849644861114046,
      0.9460975015284948,
      0.9270875434982998,
      1612467919
    ],
    [
      0.5084204606285414,
      0.6327498385835205,
      0.7234090821460863,
      784917789
    ],
    [
      0.8641532142014025,
      0.2696795273896677,
      0.21300438335770946,
      1166561007
    ],
    [
      0.6842819497381719,
      0.10087060700211237,
      0.3484976507483505,
      686316417
    ],
    [
      0.27328705707252354,
      0.2811392360744715,
      0.3885680466837101,
      1938705260
    ]
  ]
]

Occupa 650 byte, poco più della metà. Riducendo i decimali di default (spesso non serve tutta quella risoluzione, ovviamente dipende dal contesto) arriviamo a circa 400 byte. A parità di banda significa raddoppiare il numero di client connessi contemporaneamente, raddoppiare il rate di invio dei dati o una combinazione dei due.

Per lunghi array di valori numerici, ad esempio per dati relativi a grafici la serializzazione senza nomi risulta particolarmente efficiente e si adatta bene a linguaggi loosely typed come Javascript e PHP.

Ad esempio:

[
   [
      0.5849644861114046,
      0.9460975015284948,
      0.9270875434982998,
      0.8641532142014025
    ],
    [
      0.5084204606285414,
      0.6327498385835205,
      0.7234090821460863,
      0.2811392360744715
    ],
    [
      0.8641532142014025,
      0.2696795273896677,
      0.21300438335770946,
      0.2696795273896677
    ],
    [
      0.6842819497381719,
      0.10087060700211237,
      0.3484976507483505,
      0.9270875434982998
    ],
    [
      0.27328705707252354,
      0.2811392360744715,
      0.3885680466837101,
      0.6327498385835205
    ],
    [
      0.8641532142014025,
      0.2696795273896677,
      0.21300438335770946,
      0.2696795273896677
    ]
]

Ho trovato la soluzione con i dynamic abbastanza utile e veloce da implementare ma credo ne esistano altre. BSON per esempio? Oppure Message Pack.