Microsoft Bond é uma nova estrutura de serialização para dados esquematizados criados pela Microsoft.

Vamos recapitular onde a serialização de dados é mais usada:

• Persistência de dados em arquivos, fluxos, NoSQL e BigData.
• Transmissão de dados em redes, IPC, etc.

Normalmente, esses aplicativos precisam lidar com dados esquematizados, onde esquema significa:

• Estrutura: hierarquia, relações, ordem.
• Semântica: idade em número de anos desde o nascimento.

Na verdade, todos os dados têm esquema, mesmo que sejam implicitamente definidos ou suportados por sua linguagem de programação pronta para uso. Quando se trata de estruturas de dados complexas, acabamos escrevendo objetos de transferência de dados de suporte (DTOs) e código responsável por IO, geralmente em diferentes linguagens. Assim que ele cresce e evolui, rapidamente se torna um pesadelo manter todas essas peças. É aqui que as estruturas de serialização ganham o jogo.

Em primeiro lugar, qualquer estrutura de serialização define uma abstração para a definição do esquema de dados que não está vinculada a uma plataforma ou linguagem de programação específica. Esta abstração é conhecida como DSL (idioma específico do domínio) .

Com essa DSL, podemos definir o esquema de dados para um aplicativo específico. A definição, por sua vez, pode ser expressa em vários formulários, mas muitas vezes as estruturas de serialização suportam um único formulário que é adequado para sua DSL. Muito complicado? Aqui está um exemplo conhecido: XSD e XML.

XSD define um DSL, XML é (recomendado) para definir documentos que correspondam ao esquema XSD. Mas, você também pode usar “xsd.exe” para gerar classes DTO correspondentes ao XSD, portanto, as classes geradas são apenas outra forma. Observe que você pode gerar XML a partir de DTOs e vice-versa e eles serão semanticamente idênticos, pois a semântica é comum: é definida com o XSD. Para resumir, uma estrutura de serialização fornece uma DSL, que você usa para definir esquemas de dados em um determinado formato que é melhor suportado pela estrutura fornecida.

O esquema de dados abstratos deve ser eventualmente materializado em um conjunto de entidades expressas em uma linguagem de programação. Todas as estruturas de serialização fornecem ferramentas especiais chamadas geradores de código.

Eles geram todo o código de suporte para linguagens de programação de destino, que é necessário para os clientes trabalharem com dados esquematizados: DTOs, proxy, etc. Isso é necessário para linguagens fortemente tipadas, embora possa ser opcional para linguagens tipo duck (dinâmicas) .

A última, mas não menos importante, é a persistência dos dados na transmissão. Os dados reais serão eventualmente serializados em bytes brutos (ou texto) e desserializados de volta.

Todas as estruturas de serialização de dados fornecem outra abstração aqui chamada de protocolos. Um protocolo define um conjunto de regras que definem como os dados estruturados devem ser serializados ou desserializados de acordo com seu esquema. Cada protocolo é normalmente implementado para todas as linguagens de programação e plataformas suportadas por uma determinada estrutura de serialização. Quanto mais linguagens / plataformas de programação ele suporta, mais implementações ele deve fornecer.

Imagine que uma estrutura está disposta a oferecer suporte ao protocolo JSON, então deve fornecer leitor / gravador JSON para, digamos, C #, C ++, Windows, Linux, etc.

Juntando tudo: qualquer estrutura moderna de serialização de dados fornece o seguinte:

• Abstrações: DSL e protocolos.
• Ferramentas de geração de código.
• Implementações de protocolo.

O Microsoft Bond é uma estrutura de serialização de dados moderna. Ele fornece DSL poderoso e protocolos flexíveis, geradores de código para C ++ e C # , implementações de protocolo eficientes para Windows, Linux e Mac OS X.

Por vários anos, Bond permaneceu como uma tecnologia apenas de uso interno, mas graças à iniciativa de código aberto da Microsoft, Bond foi disponibilizado no GitHub: Microsoft Bond .

Concorrentes de serialização de dados

A rivalidade entre os gigantes do software levou ao aparecimento de uma série de estruturas de serialização:

• Google Inc. - Buffers de protocolo do Google
• Facebook Inc. - Thrift , que agora é mantido pela Apache
• Apache Foundation Software - Euro

Obviamente, todos eles são incompatíveis, o que está certo, a menos que você torne sua API pública usando um deles.

Cada um deles tem prós e contras, então você pode escolher entre eles de acordo com suas necessidades.

Por que Bond?

A resposta oficial a esta pergunta está aqui: “Por que Bond” .

Aqui está o resumo rápido:

• Bond suporta sistema de tipo rico incluindo genéricos.
• Bond oferece suporte para controle de versão de esquema e compatibilidade bidirecional.
• Bond oferece suporte à manipulação de esquema em tempo de execução.
• Bond suporta várias coleções: “vetor, mapa, lista”.
• O vínculo suporta serialização preguiçosa com segurança de tipo: “vinculado”
• O Bond oferece suporte a protocolos (formatos) conectáveis ​​com empacotamento e transcodificação

Uma observação importante é que Bond segue a estratégia de “pagar para jogar”. Quanto mais recursos você adicionar / usar, mais você paga pelo tamanho e velocidade. Isso dá aos desenvolvedores grande flexibilidade.

Vamos ser honestos e listar as desvantagens também:

• Bond está mirando Pilha Microsoft com suportando C ++ e C # , mas não oferece suporte a Java (ainda).
• O vínculo não suporta o tipo de união (“oneof” em protobuf).

E quanto ao desempenho?

Quando se trata de comparar uma estrutura a outra, desenvolvedores frequentemente procuram comparações de desempenho. Mas vamos lembrar que essas estruturas consistem em DSL, geradores de código e protocolos. Se você considerar apenas o desempenho dos protocolos, perderá os recursos fornecidos pelo DSL e codegens. Às vezes, ter um DSL melhor é muito mais importante do que ter uma pequena diferença percentual na velocidade de serialização.

Além da velocidade, as codificações com espaço eficiente suportadas por alguns protocolos também podem ser importantes. Recomendo que você faça uma comparação de desempenho / espaço com os dados específicos do seu domínio. Essa é a única maneira de estimar todos os benefícios que você poderia obter de uma estrutura específica.

Este artigo vem com o projeto de demonstração que demonstram o uso da estrutura Bond lendo todos os registros do Windows Application Event Log, serializando-os como objetos Bond e desserializando-os de volta.

Para construir e executar a demonstração, você não precisa instalar nenhum software diferente do Visual Studio.

Usando o Microsoft Bond

Obtendo Bond

Verifica o guia oficial para obter Bond para sua (s) plataforma (s).

Para projetos .NET, isso é tão simples como:

install-package Bond.CSharp

O pacote inclui:

• Gerador de código (gbc.exe) na pasta bin
• Bibliotecas .NET
• Tarefas MSBuild

Fluxo de Trabalho

O fluxo de trabalho inclui as seguintes etapas:

• Aprenda DSL e defina o esquema de dados escrevendo arquivo (s) “.bond”.
• Use o gerador de código (“gbc.exe”) para obter DTOs para sua linguagem de programação.
• Faça referência aos arquivos gerados, bem como às bibliotecas de tempo de execução do Bond em seu projeto.

Considere o uso de tarefas MSBuild fornecidas com a estrutura para automatizar a etapa de geração de código.

Visão geral dos recursos DSL

Ao começar a escrever seu primeiro arquivo “.bond”, você precisará conhecer sua sintaxe e recursos. Visite o página de documentação oficial descrevendo o IDL em detalhes. Vamos revisar apenas os recursos básicos:

• Módulos: o esquema pode ser dividido em diferentes arquivos, que estão incluídos na instrução “import”.
• Namespace: tem o mesmo significado que C ++ / C #.
• Estruturas definidas pelo usuário: uma unidade de definição de tipo de usuário.
• A declaração de encaminhamento é útil para estruturas de dados recursivas.
• Tipos básicos: “bool, uint8 (a 64), int8 (a 64), float, double, string, wstring”.
• Tipos de recipientes: “blob, lista, vetor, conjunto, mapa, anulável”.
• Aliases de tipo personalizado e mapeamento, por exemplo se você deseja ter “DateTime” em C #, mas ticks (“int64”) na conexão.
• Atributos personalizados: úteis para geração de código personalizado.

Entediado? Aqui está um exemplo:

namespace MyProject struct MyRecord { 0: string Name = 'Noname'; 1: vector Constants; }

onde “0” e “1” são os números ordinais do campo (podem ser quaisquer inteiros com qualquer ritmo) e = 'Noname' é o valor padrão (opcional).

Geração de Código

O framework Bond fornece uma ferramenta de geração de código escrita em Haskell. Aqui está como gerar código C # e C ++ a partir de um esquema “.bond” na linha de comando:

gbc c# example.bond gbc c++ example.bond

Protocolos Suportados (formatos)

O Bond pronto para uso é compatível com três tipos de protocolos:

• Protocolos marcados: “CompactBinary” e “FastBinary”

Os protocolos marcados intercalam os metadados do esquema na carga útil. Isso torna a carga útil autodescritiva, permitindo que os consumidores a interpretem mesmo sem conhecer o esquema usado pelo produtor.

• Protocolos não marcados: “SimpleBinary”

Os protocolos não marcados serializam apenas dados e, portanto, exigem que os consumidores conheçam o esquema de carga útil por meio de algum mecanismo fora de banda. Os protocolos não marcados são frequentemente usados ​​em cenários de armazenamento porque permitem armazenar um esquema uma vez (por exemplo, em uma tabela do sistema em um banco de dados), eliminando assim a sobrecarga de metadados de muitos registros usando o mesmo esquema.

• Protocolos baseados em DOM: “SimpleJson” e “SimpleXml”

O protocolo baseado em DOM analisa a carga útil inteira em um Modelo de Objeto de Dados na memória que é então consultado durante a desserialização. Normalmente, esse tipo de protocolo é usado para implementar codificações baseadas em texto, como JSON ou XML.

Para cada protocolo, a biblioteca de tempo de execução do Bond fornece as classes Reader e Writer correspondentes, que fazem o trabalho na serialização real.

Usar os protocolos é bastante simples e um pouco mais difícil do que o famoso “JsonConvert.SerializeObject ()”:

var record = new MyRecord { Name = 'FooBar', Constants = { 3.14, 6.28 } }; var output = new OutputBuffer(); var writer = new CompactBinaryWriter(output); Serialize.To(writer, record); var input = new InputBuffer(output.Data); var reader = new CompactBinaryReader(input); record = Deserialize.From(reader);

Qual é o próximo?

Se você adora Bond e tem muito tempo livre para programar, considere levar um desses itens para o desenvolvimento. Não vou enumerar todos os benefícios que você pode obter ao contribuir, mas sei que muitos desenvolvedores estão procurando ideias para contribuir com:

• Implemente uma porta para Java. Substitua o Java por outras linguagens convencionais à sua escolha.
• Implemente a importação / exportação do esquema Bond para trocar com outras DSLs (por exemplo, “.proto .bond”).

O que quer que você decida fazer em relação a Bond, recomendo que você entre em contato Adam Sapek primeiro. Ele é o líder deste projeto e irá guiá-lo com o que o mercado mais procura.