Olá,

Acaba de ser lançado um recurso muito legal para o Visual Studio 2010 Ultimate, o Debugger Canvas, que é uma maneira mais visual de fazer debug de suas aplicações.

Normalmente, ao fazer debug de uma aplicação, você executa e vai percorrendo linha a linha, entrando e saindo de rotinas dentro do código e depois de algum tempo, você acaba com diversas janelas abertas no Visual Studio.

Agora imagine que ao fazer o debug, os diferentes códigos fontes vão se abrindo e se relacionando, formando um caminho percorrido pelo fluxo de execução, mais visual, não serial muito bom ? Pois é exatamente isto que o Debugger Canvas faz.

Para começar, vamos instalar o debugger canvas, que é um plugin para o Visual Studio Ultimate e pode ser baixado aqui.

Agora abra um projeto você está acostumado a fazer debug, no meu caso, vou abrir o projeto TailspinToys, que é um projeto exemplo da Microsoft. Vamos executá-lo (F5) e ver o que acontece com o debug.

Primeiro vamos abrir o CartController.cs e colocar um break point no método AddCart()

Agora vamos executar o programa pressionando F5. Após a aplicação abrir no browser, clique em “Model Airplanes” e depois em  em “View Plane”. Em seguida clique em “Add to Cart”.

Neste ponto o código irá parar no local onde fizemos o break point, mas com uma grande diferença no visual:

Veja que agora estamos no Debugger Canvas, no codigo do controller. Em cima na barra da janela está a árvore de execução, ou seja, por onde o código passou até chegar aqui e existe também um botão no canto direito da tela que mostrar as variáveis locais para o método:

Vamos executar o código pressionando F11 para entrar em algum outro método e logo em seguida temos esta outra janela:

Pressionando mais algumas vezes o F11 temos o seguinte:

Fazendo um pequeno ajuste visual temos o seguinte:

Aqui vemos a linha de execução do programa até onde paramos, ou seja, se continuarmos a execução teremos um mapa visual de todo o fluxo de execução da nossa aplicação, e o que ganhamos com isto ? Facilidade para entender como o código funciona.

Uma última coisa é que quando você instala o Debugger Canvas, ele fica como padrão para o seu debug e caso você queira ativar/desativar, basta abrir o menu Debug/Debugger Canvas/Options and Settings de desmarcar a propriedade abaixo:

Espero que vocês tenham gostado do potencial deste novo recurso para o Visual Studio e isto mostra mais uma vez que a ferramenta está evoluindo e tem muito mais a evoluir.

Abraços e até a próxima.

Carlos.

Pessoal,

A Microsoft acabou de lancar o Power Tools para o EF Code First. Com este pacote é possível ler um banco de dados existente e gerar todas as classes, muito interessante se você já tem um banco e quer usar o EF Code First.

O pacote pode ser instalado via Extension Manager do Visual Studio 2010. Maiores informações neste link: http://blogs.msdn.com/b/adonet/archive/2011/05/18/ef-power-tools-ctp1-released.aspx

Abraços,

Carlos.

Para quem já conhecia o componente de impressão matricial, eu fiz um update nele e agora é possível usar em Windows 7. Estou também fornecendo os fontes do componente para aqueles que queiram estudar e aprimorar.

O link para o novo componente é: http://code.msdn.microsoft.com/Impresso-Matricial-20-cb6579af

Áté a próxima,
Carlos dos Santos.

Na última sexta-feira (08/04/2011) estive no Instituto Federal Tecnológico do Paraná (http://www.ifpr.edu.br/) para ministrar uma palestra para os alunos do curso técnico em informática.

Neste evento falei sobre o Visual Studio 2010 e a linguagem C# para a criação de aplilcações Windows, WPF, Silverlight e Windows Phone, mostrando todo o ppotencial da plataforma .Net.

Falei também sobre o mercado de trabalho em .Net, que vem crescendo a cada ano e principalmente da importância da capacitação para quem quer uma vaga no mercado.

Gostaria de agradecer ao Prof. Rodolfo Barriviera pela oportunidade e pela conversa sobre como o Instituto está empenhado em entender o mercado regional e prover mão de obra qualificada para as empresas.

Vejam as fotos:

Abraços e até a próxima,
Carlos dos Santos.

Pessoal, seguindo com os posts sobre C# básico, vou mostrar como passar parâmetros para uma aplicação em .Net usando C# em um Windows Forms.

Primeiramente crie uma aplicação Windows Forms:

Eu estou usando o Visual Studio 2010 e o Framework 4, mas você pode usar qualquer versão do Visual Studio para executar este exemplo.

Após criar a aplicação vamos ao arquivo Program.cs, onde vamos colocar a variável que irá receber os parâmetros:

   1: [STAThread]

   2: static void Main(string[] parametros)

   3: {

   4:     Application.EnableVisualStyles();

   5:     Application.SetCompatibleTextRenderingDefault(false);

   6:     Application.Run(new frmPrincipal());

   7: }

Neste exemplo eu criei uma variável chamada parametros que irá receber os argumentos da linha de comando. Se você precisa usar o parâmetro somente para acionar alguma parte do seu programa, pode fazer assim:

   1: static void Main(string[] parametros)

   2: {

   3:     if(parametros.Length > 0)

   4:     {

   5:         if(parametros[0].ToUpper() == "/CONFIG")

   6:         {

   7:             frmConfig config = new frmConfig();

   8:             config.ShowDialog();

   9:             Application.Exit();

  10:             return;

  11:         }

  12:     }

Primeiro você testa se recebeu algum parâmetro e depois faz a verificação. Eu fiz a conversão para Upper() fica mais simples a verificação. Agora você pode estar se perguntando, como vou fazer debug da aplicação e passar o parâmetro ? Isto você pode configurar na janela de propriedades do projeto em Project/Properties/Debug:

Se você precisar testar mais de um parâmetro ao mesmo tempo, basta colocá-los separados por espaços, do mesmo modo que faria no prompt de comandos. Agora para finalizar, vou mostrar como passar o parâmetro para o form principal da aplicação. Para isto teremos que modificar o construtor do form, veja:

   1: public partial class frmPrincipal : Form

   2:     {

   3:         public frmPrincipal(string[] parametros)

   4:         {

   5:             InitializeComponent();

   6:         }

   7:     }

Na verdade acrescentamos o parâmetro no construtor do form, mas se você precisar passar qualquer outra informação, basta modificar o construtor. Agora vamos voltar no program.cs e passar o parâmetro:

   1: Application.Run(new frmPrincipal(parametros));

É isto aí pessoal, um abraço e até a próxima.

Carlos dos Santos

É relativamente comum termos uma aplicação que precise usar uma ou mais threads para realizar algum processo demorado onde o usuário não precise ficar esperando, mas às vezes é necessário também que esta thread faça algum tipo de interação com a tela, talvez atualizando alguma informação, barra de progresso, enfim, mostrar ao usuário que algo está acontecendo.

Uma tarefa relativamente simples, mas que pode causar um certo transtorno justamente por ser uma thread. Veja a aplicação abaixo em Windows Forms:

É uma tela bem simples, com um botão e uma barra de progresso. Agora vamos imaginar que este form tenha o código abaixo, que cria uma thread que atualiza a progressBar1:

   1: public partial class Form1 : Form

   2: {

   3:     private bool threadAtiva = false;

   4:  

   5:     public Form1()

   6:     {

   7:         InitializeComponent();

   8:     }

   9:  

  10:     private void btnIniciar_Click(object sender, EventArgs e)

  11:     {

  12:         

  13:         Thread processo = new Thread(new ThreadStart(ExecutaThread));

  14:         processo.Start();

  15:  

  16:         progressBar1.Maximum = 100;

  17:         progressBar1.Value = 0;

  18:  

  19:         threadAtiva = true;

  20:     }

  21:  

  22:     void ExecutaThread()

  23:     {

  24:         while (threadAtiva)

  25:         {

  26:             if (progressBar1.Value > 99)

  27:             {

  28:                 threadAtiva = false;

  29:                 return;

  30:             }

  31:             progressBar1.Value++;

  32:             progressBar1.Refresh();

  33:         }

  34:     }

  35: }

O código acima está correto, mas ao executar e clicar no botão iniciar, aparece o seguinte erro:

O erro acontece porquê a janela da aplicacação (UI) está executando em uma thread e agora nós temos outra thread executando o nosso processo e tentando atualizar a tela. Então como resolver isto ?

Simplesmente usando um Invoker:

   1: void ExecutaThread()

   2:        {

   3:            while (threadAtiva)

   4:            {

   5:                if (progressBar1.Value > 99)

   6:                {

   7:                    threadAtiva = false;

   8:                    return;

   9:                }

  10:                this.Invoke(new MethodInvoker(delegate()

  11:                {

  12:                    progressBar1.Value++;

  13:                    progressBar1.Refresh();

  14:                }));

  15:            }

  16:        }

Agora estamos atualizando a tela ou seja, o progressBar1 usando um Invoker que está sendo executando sob a thread principal, ou seja, o formulário. Neste exemplo eu usei o MethodInvoker() com um método anônimo, mas você poderia ter criado um método e chamado sem problemas e com isto você pode ter várias thread rodando e atualizando a interface do usuário.

É isto aí pessoal, espero que dica seja útil para vocês.

Um abraço e até a próxima.

Carlos dos Santos.