Come tradurre da definizioni di classi native gestite

Ho un file di input, che è la DLL di un pezzo di codice C #, contenente definizioni di classi gestite.
Ho anche un file * .json, che determina come deve essere eseguita la conversione.

Ad esempio, questo è il codice C # per una particolare classe gestita:

namespace <Company>.<Product>.<Chapter>.Messages
{
  [Serializable]
  public class GetInfoMessage : TargetedClientRequestMessage
  { ...

Ecco come appare il corrispondente file di configurazione * .JSON:

{
  "Class": "<Company>.<Product>.<Chapter>.Messages.GetInfoMessage",
  "Fields": [ "Type" ],
  "ConstructorFields": [ "Type" ]
},

Attualmente viene scritto un convertitore per l'esecuzione automatica della conversione "Managed-to-Native", il risultato di questa conversione è il seguente (solo il file di intestazione):

class GetInfoMessage: public <Company>::<Product>::<Chapter>::messages::TargetedClientRequestMessage, public ::serialization::SerializableObjectRegistration<GetInfoMessage> {
protected:

    #pragma region private members
    InfoType type_;
    #pragma endregion private members

public:
    explicit GetInfoMessage(InfoType type);
    explicit GetInfoMessage();

    #pragma region getters & setters
    InfoType getType() const;
    void setType(InfoType type);
    #pragma endregion getters & setters
    bool operator==(const GetInfoMessage&lhs) const;
    bool operator<(const GetInfoMessage&lhs) const;
    virtual void serialize(::serialization::Archive & ar) override;
    CloneableMessage(GetInfoMessage)

}; // end of class GetInfoMessage

Il codice sorgente di questa conversione (scritto qui in-house) è davvero brutto, come puoi vedere dal seguente estratto:

W.WriteLine(" {");
W.WriteLine();
W.WriteLine("public:");
W.Indent++;
W.WriteLine();

Questo mi fa chiedere perché la mia azienda abbia scritto il proprio convertitore di definizione di classe "Managed-to-Native", vedo due inconvenienti:

• manutenibilità: non appena una nuova funzione viene utilizzata dai creatori delle definizioni della classe gestita, il convertitore deve essere aggiornato.
• unicità dell'output: il convertitore è scritto esclusivamente per generare file header C ++ (estensione .h) e file di codice sorgente (estensione .cpp), quindi ogni volta che si deve usare un nuovo linguaggio, è necessario scrivere un nuovo convertitore ( Sto pensando in particolare alla lingua R ).

Quindi mi chiedo: non c'è altro modo per convertire i tipi di classi gestite in tipi nativi, se possibile in diversi formati di output leggibili?

Ho accesso al codice sorgente C #, nel caso in cui questo potrebbe essere necessario.

Grazie in anticipo

P.S. Nel caso ti chiedi "Ma perché non usi semplicemente il JSON come file di intestazione?" oppure "Perché stai usando JSON in questo modo, questo è il modo sbagliato per farlo, devi farlo in questo modo: ...", tieni conto che questa è la prima volta che sono in contatto con JSON .