Criando Windows Forms Dinamicamente com JSON / Dynamic Windows Forms with JSON

Português   English

Photo by Iker Urteaga on Unsplash

Recentemente tive algum trabalho para fazer integração de relatórios com um projeto legado em Windows Forms por conta de a nova versão ter algumas incompatibilidades com versões anteriores.

Meu maior problema era a passagem de parâmetros para a montagem de um relatório a partir das opções que o usuário iria enviar.

Durante o processo notei que se fosse possível criar um formulário dinamicamente para a coleta dos dados esta tarefa seria completada mais facilmente.

Aplicações desktop usando Windows Forms estão por aí há muito tempo e mesmo que estejam começando a decrescer em utilização - dificilmente surgem novos projetos principalmente por conta da adoção em massa de tecnologias voltadas à nuvem - ainda irão continuar pois o .Net Core está preparando o suporte para este tipo de aplicações. Mais sobre isso na seção de links no final do post.

Assim, fiz uns testes para saber se seria possível unir a versatilidade do JSON com Windows Forms para criar formulários dinâmicos para coleta de dados.

Atualmente JSON está por quase toda a parte e existem bibliotecas como a Newtonsoft JSON para .Net que facilita muito o trabalho.

Abaixo uma amostra de um formulário construído usando o projeto (que pode ser baixado no meu GitHUB:).

In one of my recent legacy Windows Forms projects I had some difficulties to integrate the software with the new version of a new report library. That release has some incompatibilities with previous one.

My main issue was with to send parameters to show a new report using the data sent by the user.

I wonder that if would be possible to build a dynamic form to accomplish that task.

Windows forms applications there is for a long time. Despite their decreasing utilization - it's rare to see new projects based on it - they still important. Therefore the new .Net Core Framework is planning to support that type of projects also in new platforms like LINUX systems.

Thus, I built a project to test if could be possible join the JSON adaptability with Windows Forms to build dynamic forms to collect data.

Nowadays JSON is used everywhere and there are libraries like Newtonsoft JSON .Net that makes integration easy.

In the picture bellow is shown a sample of a form built based on the project (that can be downloaded from my GitHUB):).

A linguagem JSON permite que sejam expressos objetos complexos usando uma sintaxe bem simples. É muito fácil criar listas e hierarquias. No meu projeto a ideia foi ter uma lista com os controles mais básicos:

• Text Box
• Check Box
• Date Time Picker
• Combo box

E expressá-los com JSON:

JSON data notation language allows that complex data and objects can be expressed in a simple way. It's easy to create lists and hierarchical objects. In my project I made a list supporting the most basic controls that are used on Windows Forms as follow:

• Text Box
• Check Box
• Date Time Picker
• Combo box

That is the sample how the JSON code can by written:

{
"name":"form1",
"text":"Primeiro formulário",
"type":"OK",
"controls":[
  {
    "name":"txtText1",
    "type":"TextBox",
    "key":"text1",
    "label":"Campo texto",
    "initialValue":"Some text"
  },
  {
    "name":"chkCheck1",
    "type":"CheckBox",
    "key":"check1",
    "label":"Campo Lógico",
    "initialValue":"false"
  },
  {
    "name":"dtDate",
    "type":"DateTime",
    "key":"date1",
    "label":"Data inicial",
    "initialValue":"2019-01-22"
  },
  {
    "name":"cboName",
    "type":"ComboBox",
    "key":"name1",
    "label":"Campo múltipla escolha",
    "initialValue":"1",
    "bindingSource": {
      "connection":"Data source=localhost\\sqlexpress2014; Initial catalog=adventureworks2012; Integrated security=true;",         "sql":"select id, name from programmers order by name",
        "keyValue":"id",
        "displayValue":"name"
  }}]

}

Para todos os controles existirão propriedades comuns usadas para o nome, o tipo do controle, qual o rótulo para o campo e um valor inicial.

Estes controles contidos no JSON são validados pelo projeto ao serem convertidos para objetos no C#.

Para o controle Combo Box foi criada a possibilidade de se usar items de uma lista fixa, onde os valores devem vir separados por ponto e vírgula ou a partir de uma consulta SQL em um banco de dados SQL Server.

Quando for necessário expressar o binding do controle ComboBox com itens de uma lista pré-definida basta fazer a notação como segue:

There are common properties for all the controls like name, type and the label plus an initial value for the control.

The objects that are represented on JSON are validated by the project when converted to objects in C#.

An important feature is the capability to data bind a combo box control using a SQL Server Query (like expressed in the previous code) or a list where the items are semicolon separated.

Again, you can see a sample for the how data can be expressed in JSON code:

        {
            "name":"cboName2",
            "type":"ComboBox",
            "key":"options",
            "label":"Tipo do relatório",
            "initialValue":"Geral",
            "bindingSource": {
                "connection":"",
                "sql":"",
                "keyValue":"",
                "displayValue":"",
                "items":"Geral;Parcial;"
            }
        }

Nesta fase não foi dado suporte a outros bancos de dados pois trata-se apenas de uma prova de conceito, um MVP se preferir.

Um dos pontos importantes a se observar ao usar JSON para expressar classes do C# é que usualmente os nomes das propriedades deste são expressos usando "camelCase o" que é diferente do C#.

Não haveria problema em se usar o mesmo tipo de notação do C# no JSON e vice-versa, porém, preferi manter o padrão das duas linguagens.

Para o C# poder fazer o mapeamento correto das propriedades expressas no JSON foi usado o recurso de criar atributos conhecidos como Data Annotations.

Modelagem e preparo para usar JSON:

In this phase of the project there isn't support for another types of databases because it is just conceptual project, or, MVP.

One of my issues in this project was to correctly mapping properties both on C# and JSON. Usually on JSON properties are expressed with "camelCase" notation.

It would be OK to use the same type on C# but there is a way to create alias on C# for the properties on JSON so, I do that.

Newtonsoft JSON .Net library allow you to create data annotations above your properties that indicate what is the name of the property on JSON.

Here is how the code looks like:

[Serializable] public class DynamicDialog { #region fields string _dialogType; IEnumerable<string> _validDialogTypes = new List<string>() { "OK", "YesNo" }; DynamicForm _DynamicForm; #endregion #region properties [JsonProperty(PropertyName = "name")] public string FormName { get; set; } [JsonProperty(PropertyName = "text")] public string Text { get; set; } [JsonProperty(PropertyName = "type")] public string DialogType { get { return _dialogType; } set { if (_validDialogTypes.Contains(value)) { _dialogType = value; } else { throw new Exception("Dialog type is not valid.\nCurrent valid types are:\n\n\t\"OK\" and \"YesNo\""); } } } [JsonProperty(PropertyName = "controls")] public List<DynamicControl> DynamicControls { get; set; } #endregion

O código procura manter tudo o mais simples possível. O formulário onde os controles são dispostos é um Windows Forms com um design pré-definido e com os botões que fazem o retorno já colocados e alinhados corretamente.

The main goal of the code is to keep things simpler. The form where the controls are shown is pre designed with some features and controls.

Dentro deste formulário os controles são aninhados dentro de um componente container Panel que permite usar uma barra de rolagem já que há um limite máximo de altura para o form.

A maior dificuldade encontrada foi fazer o alinhamento dos controles e o controle do seu tamanho. Para isso foram criadas as propriedades:

• _labelWidth: controla a largura do rótulo dos campos
• _controlWidth: para a largura dos controles
• _panelOffset: controla o espaçamento dos controles e ajuda a redimensionar dinamicamente o formulário.
• _controlOffset: para o espaçamento entre os controles.

Preparo para montar o formulário:

Inside this form the controls are grouped on a component of Panel type that allows to create a vertical scroll bar in an automatic way when the windows form max height is reached.

The main issue that I had was to align the controls and their widths. To achieve this, inside de code of the form I created some helper properties:

• _labelWiidth: to control the controls labels width.
• _controlWidth: to control the controls width.
• _panelOffset: used to control the spacing between components and to automatically resize the form.
• _controlOffset: to control the controls spacing.

Ao se trabalhar com geração dinâmica dos controles visuais é necessário ir fazendo ajustes para controle do espaçamento entre estes e o ajuste automático da largura e altura do formulário.

No método CreateDynamicControls todos estes cuidados são tomados.

When we are working with dynamic forms generation its necessary to make some adjusts to keep the visual appearance correct.

That job is achieved on the CreateDynamicControls method.

public partial class DynamicForm : Form { public Dictionary<string, string> dicReturnValues { get { return _returnValues; } } List<DynamicControl> _dynamicControls; Dictionary<string, string> _returnValues; int _labelWidth = 150; int _controlWidth = 350; int _panelOffset = 20; int _controlOffset = 2;

Uma vez que os controles estão configurados os valores retornados serão obtidos ao clicar no botão de confirmação (que dá como DialogResut o valor OK). O método FillReturnValues percorre o dictionary que foi criado na configuração.

Cada controle deve possuir uma chave única informada no JSON com o atributo "key". Este nome é armazenado na propriedade "Tag" do controle.

O projeto consiste de uma class library monolítica: WindowsForms (eu sei... Pode dar algum conflito na integração) escrita na versão 4.0 do Framework, o que a torna atraente para a maior parte dos projetos Windows Forms.

Esta possui dependência da biblioteca Newtonsoft JSON .NET que também pode ser facilmente integrada em outros projetos.

Alguns pontos do código merecem uma refinada como no caso do controle combo box, não há verificação de segurança para a instrução SQL que é enviada. Isto pode possibilitar algum tipo de ataque.

Neste estágio se for enviado um JSON incorreto a aplicação simplesmente informa que não foi possível montar o formulário não dando maiores pistas sobre o que houve.

Fique à vontade para examinar o projeto. Se tiver sugestões entre em contato por e-mail que está no meu perfil. Até a próxima.

Once the form and the controls are done, the values that are informed are got after the user click on the accept button. The FillReturnValues method runs over the dictionary property that was created during the form configuration to store the data.

Every control must have a unique key that is expressed on the JSON like "key" attribute. This name is stored in "Tag" controls property.

This project consists in a class library called WindowsForms that can be easily integrated with any Windows Forms project above the .Net Framework 4.0 version.

There is a dependence with NewtonSoft .Net Nuget package than can be added to another projects too.

Some points of the code deserves a review especially the combo box control. There is no security verification against the SQL that's sent. In this case, there is a SQL Injection attack failure that can be explored.

Also, in this stage, if an incorrect JSON code will be sent the application just notify that it was not possible to build the form and doesn't give any detail about the problem.

Feel free to explorer the project. If you have any suggestion please contact me sending an e-mail that is in my profile. Bye!

Links

• Visual Studio 2019 e .NET Core 3: primeiros testes
• Primeiras impressões do .NET Core 3.0: C# 8, WPF, Windows Forms e mais
• .NET Core 3 and Support for Windows Desktop Applications
• Newtonsoft JSON
• MVP - The Minimum Viable Product and Incremental Software Development
• Como mapear atributos JSON nas propriedades de classes do C#