Posts tagged ‘c#; msdn’

MVA Student to Business–Desenvolvimento de Sistemas

Olá pessoal,

Recentemente eu gravei um vídeo sobre o Visual Studio 2015 para o programa Student to Business. Neste vídeo eu dou uma visão geral do Visual Studio e da Plataforma .Net, mostro também algumas das plataformas e o que é possível fazer com ela.

Se você é um iniciante na ferramenta ou até mesmo quer entender melhor o que ela faz, recomendo que você assista ao vídeo clicando aqui.

Este é um treinamento do MVA, e tem outros conteúdos, então você pode assistir aos vídeos e também fazer as provas.

Abraços,
Carlos dos Santos.

Capturando a tela em Windows Forms

Olá pessoal,

Hoje vou demonstrar como é possível capturar a tela ou até mesmo o conteúdo de um controle e salvá-lo como um Bitmap. Imagine que você tem uma solução de atendimento ao cliente e em algum momento precise capturar a tela do seu usuário e depois anexá-la a algum requisito do software ou tratamento de um bug.

Claro que existem várias ferramentas prontas para captura de tela, mas vamos ver como é possível, através de um código em C# usando o recurso de Interop e acessando a API do Windows, criar um método reusável que pode ser utilizado para capturar vários tipos de tela no Windows.

Criando o projeto

Vamos criar um projeto no Visual Studio 2013 do tipo Windows Forms (você pode utilizar qualquer outra versão do Visual Studio):

SNAGHTML29cbc21f

Para deixar o nosso código de captura reutilizável, vamos criar uma nova classe chamada Tela.cs. Nesta classe iremos criar todo o código de captura, iniciando pelas referências a API do Windows. Esta API é muito rica e possui centenas de métodos muito interessantes, mas vamos nos concentrar basicamente nas rotinas de captura de tela.

Só para conhecimento, todos os controle do Windows são tratados como uma janela e como tal, possuem um identificador único de janela, ou um WindowsHandle. Para acessarmos qualquer informação de uma janela ou controle usando a API do Windows, precisamos deste identificador.

Trabalhando com Interop

Para começar a nossa classe, vamos colocar todo o código de Interop com a API do Windows. Eu não vou explicar em detalhes o que cada método faz, mas você pode acessar um site muito bom chamado PInvoke.net que contém referências, explicações e exemplos para a API do Windows.

O código abaixo faz uma referência para um método da API do Windows e o deixa acessível para nós no C#:

   1: public class Tela

   2:     {

   3:         [DllImport("user32.dll", EntryPoint = "GetDC")]

   4:         static extern IntPtr GetDC(IntPtr ptr);

   5:         [DllImport("user32.dll", EntryPoint = "ReleaseDC")]

   6:         static extern IntPtr ReleaseDC(IntPtr hWnd, IntPtr hDc);

   7:         [DllImport("gdi32.dll", EntryPoint = "DeleteDC")]

   8:         static extern IntPtr DeleteDC(IntPtr hDc);

   9:         [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC")]

  10:         static extern IntPtr CreateCompatibleDC(IntPtr hdc);

  11:         [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap")]

  12:         static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, int nWidth, int nHeight);

  13:         [DllImport("gdi32.dll", EntryPoint = "SelectObject")]

  14:         static extern IntPtr SelectObject(IntPtr hdc, IntPtr bmp);

  15:         [DllImport("gdi32.dll", EntryPoint = "BitBlt")]

  16:         static extern bool BitBlt(IntPtr hdcDest, int xDest, int yDest, int wDest, int hDest, IntPtr hdcSource, int xSrc, int ySrc, int RasterOp);

  17:         [DllImport("user32.dll", EntryPoint = "GetDesktopWindow")]

  18:         static extern IntPtr GetDesktopWindow();

  19:         [DllImport("gdi32.dll", EntryPoint = "DeleteObject")]

  20:         static extern IntPtr DeleteObject(IntPtr hDc);

  21:

  22:         const int SRCCOPY = 13369376;

  23:         public struct SIZE

  24:         {

  25:             public int cx;

  26:             public int cy;

  27:         }

Entendo um pouco a API do Windows

DC – Device Context, ou Dispositovo de Contexto, é um identificador para um objeto no Windows, por exemplo uma janela ou controle.

GetDC() – devolve o identificador para uma janela.

ReleaseDC() – restaura o identificador para o Windows. Isto é muito importante, todo identificador que for utilizado, deve ser devolvido.

DeleteDC() – quando nós criamos o DC, ao invés de pegá-lo do Windows, precisamos deletá-lo para liberar o recurso.

CreateCompatibleDC() – cria um DC, no nosso caso iremos criar para manipular o Bitmap.

CreateCompatibleBitmap() – cria um Bitmap compatível com um DC.

SelectObjec() – seleciona um objeto, no nosso caso vincula o DC ao Bitmap.

BitBlt() – faz a cópia do conteúdo de um identificador para outro, e no nosso caso, o identificador de destino será um Bitmap.

GetDesktopWindow() – retorna um identificador para a janela principal do Windows (Desktop).

DeleteObject() – deleta um objeto, liberando o recurso alocado.

Criando a rotina que captura a tela

Agora que já entendemos um pouco da API do Window, vamos criar o método da nossa classe que irá fazer as capturas de tela. Para isto vamos adicionar o código abaixo a nossa classe Tela.cs:

   1: public static Bitmap RetornaImagemControle(IntPtr controle, Rectangle area)

   2:         {

   3:             SIZE size;

   4:             IntPtr hBitmap;

   5:

   6:             IntPtr hDC = GetDC(controle);

   7:             IntPtr hMemDC = CreateCompatibleDC(hDC);

   8:

   9:             size.cx = area.Width - area.Left;

  10:             size.cy = area.Bottom - area.Top;

  11:

  12:             hBitmap = CreateCompatibleBitmap(hDC, size.cx, size.cy);

  13:

  14:             if (hBitmap != IntPtr.Zero)

  15:             {

  16:                 IntPtr hOld = (IntPtr)SelectObject(hMemDC, hBitmap);

  17:                 BitBlt(hMemDC, 0, 0, size.cx, size.cy, hDC, 0, 0, SRCCOPY);

  18:                 SelectObject(hMemDC, hOld);

  19:                 DeleteDC(hMemDC);

  20:                 ReleaseDC(GetDesktopWindow(), hDC);

  21:                 Bitmap bmp = System.Drawing.Image.FromHbitmap(hBitmap);

  22:                 DeleteObject(hBitmap);

  23:                 return bmp;

  24:             }

  25:             else

  26:             {

  27:                 return null;

  28:             }

  29:         }

O nosso método recebe como parâmetro um IntPtr, que pode representar qualquer controle ou janela do Windows, e recebe também uma estrutura que representa a área que iremos capturar, pois poderemos querer apenas uma parte do nosso controle transformado em uma imagem.

Iniciamos pegando os identificadores necessários (linhas 6 e 7) e em seguida calculamos o tamanho do nosso Bitmap de captura (linhas 9 e 10), para depois já criarmos este Bitmap (linha 12). Caso consigamos criar o Bitmap, então vamos fazer o vínculo do Bitmap (linha 16), e finalmente iremos executar o método que faz toda a mágica, ou seja, que copia o conteúdo do controle para o nosso Bitmap (linha 17).

Após isto iremos liberar os recursos utilizados (linhas 19 e 20), criamos finalmente o nosso Bitmap (linha 21) e liberamos o último recurso alocado. Ufa! Agora é só retornar o Bitmap com o resultado.

Utilizando a classe para capturar uma informação:

Agora que já temos a classe, vamos voltar para o nosso Windows Forms e mostrar como ele irá funcionar. Para isto adicione um controle Button e também um PictureBox, de maneira que a tela fique parecida com a seguinte:

image

Vamos adicionar o código para o botão “Capturar Desktop”:

   1: private void btnCapturaDesktop_Click(object sender, EventArgs e)

   2:         {

   3:             imagemCapurada.Image = Tela.RetornaImagemControle(IntPtr.Zero, Screen.PrimaryScreen.WorkingArea);

   4:         }

Este código tem um truque bem interessante. Como eu falei no início deste post, iríamos capturar uma tela e toda tela no Windows possui um identificador, sendo assim, o nosso Desktop tem a identificação ZERO, ou seja, informando IntPtr.Zero como o nosso controle a ser capturado, iremos capturar o Desktop do Windows, e para conseguirmos capturar toda a tela, eu utilizei a propriedade PrimaryScreen.WorkingArea, que retorna o tamanho do nosso Desktop.

Para finalizar, iremos implementar um outro botão que irá capturar a nossa própria tela, para isto adicione um novo botão ao formulário e acrescente o código a seguir:

   1: private void btnCapturaTela_Click(object sender, EventArgs e)

   2:         {

   3:             imagemCapurada.Image = Tela.RetornaImagemControle(this.Handle, new Rectangle(0,0,this.Width,this.Height));

   4:         }

   5:

Veja que agora estamos informando o identificador do nosso form e também o seu tamanho, mas você pode informar o identificador de qualquer controle e qualquer tamanho, e talvez capturar uma parte do controle original.

Veja como fica a tela capturada:

image

Conclusão:

Este post mostra duas coisas bem interessantes: como interoperar com a API do Windows e como capturar o conteúdo de uma janela do Windows.

Espero que tenham gostado e que principalmente seja útil no seu dia a dia.

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

Carlos dos Santos.

Visual Studio 2013–Novidades

Olá pessoal,

O Visual Studio 2013 será lançado no próximo dia 13/11/2013 (para assinantes do MSDN já está disponível) e junto com esta nova versão temos melhorias muito interessantes na IDE, que tornam o nosso dia a dia ainda mais produtivo.

Neste post vou mostrar algumas destas novas funcionalidades que eu particularmente uso a todo momento e que ajudam muito no desenvolvimento. Enão vamos lá:

Peek Definition (ALT F12)

Imagine que você está escrevendo um método qualquer e precisa verificar um método que está em outra classe, normalmente você pressionar o F2 e olha a classe, e depois volta para o seu código. Isto é bem funcional, mas tira o foco do código que você está trabalhando. Agora no Visual Studio 2013, você tem o Peek Definition, que é acionado pela tecla ALT + F12, onde o código é mostrado para você na mesma janela, em cima do método.

Eu criei um projeto bem simples, com Entity Framework 6 acessando o banco de dados NorthWind e neste projeto tem um método RetornaClientes() que simplesmente volta uma lista de clientes (A idéia aqui não é focar na funcionalidade do projeto e sim na IDE).

Veja o código abaixo:

image

Agora, com o mouse em cima do método RetornaClientes, pressione ALT F12:

image

É muito simples, agora você está vendo o código do método RetornaClientes() na mesma janela que estava trabalhando. E você pode pressionar o ALT F12 dentro desta janela também e ir navegando pelos códigos, sem precisar ficar alternando entre duas ou mais janelas.

Code Lens

Este é um recurso também muito útil, principalmente se você está trabalhando em um código de que você não conhece bem, mas como assim: quantas vezes você já precisou fazer uma busca no código para localizar a utilização de uma propriedade ou um método ? Quase sempre eu imagino! Isto toma muito tempo e abaca deixando um monte de janelas abertas na sua IDE.

O Code Lens pode te ajudar muito nisto. A idéia básica é que para cada classe, propriedade ou método, você tem uma referência logo acima do nome que indica quantas vezes ele está referenciado,ou seja, quem está utilizando esta classe, propriedade ou método.

Veja no mesmo exemplo, onde temos o Entity Framework referenciando o banco de dados NorthWind, ao abrirmos o código fonte da classe NortwindContext.cs, temos o Code Lens acima dos nomes, veja:

image

Isto quer dizer, por exemplo, que a classe NortwindContext está sendo referenciada 5 vezes. E ao clicar sobre o número:

image

E ao passar o mouse sobre as referências, você consegue ver em que parte do código fonte ele está sendo usado:

image

Sem dúvida um recurso muito útil e que vai deixar o seu dia ainda mais produtivo.

Nova Scroll Bar

Agora você pode configurar a barra de scroll do seu editor de código para deixá-la mais interessante do que apenas rolar o código. Podemos transformar a barra do scroll em um visualizador de códigos que pode facilitar a navegação pelas linhas do seu programa.

Para ativarmos este recurso, basta clicar com o botão direito do mouse sobre a barra latera e escolher Scroll Bar Options:

image

E depois é só configurar:

image

Ative a opção “Show Preview Tooltip” e depois escolha o tamanho da barra de scroll. Após a configuração você verá uma nova barra de scroll, como esta:

image

Sua barra agora contem um resumo de todo o código fonte do arquivo e ao mover o mouse sobre a barra, você verá uma prévia do código fonte.

É isto aí pessoal, espero que as dicas sejam úteis e que todos comecem a utilizar o novo Visual Studio 2013.

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

Visual Studio Debugger Canvas

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()

imageimage

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:

image

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:

image

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

image

Pressionando mais algumas vezes o F11 temos o seguinte:

image

Fazendo um pequeno ajuste visual temos o seguinte:

image

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:

image

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.

Entity Framework Code First Power Tools CTP1

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.

Impressão Matricial 2.0

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.

Palestra sobre Visual Studio e Mercado de Trabalho

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:

12

34

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

Usando Tuples em C#–retornando vários parâmetros de um método

Olá pessoal,

Uma das coisas interessantes da linguagem C# é a quantidade de opções que temos para resolver o problemas do nosso dia a dia. Um caso interessante e bem comum é termos a necessidade de passar vários parâmetros para um método e às vezes também retornar vários parâmetros, e é bem provável que você se utilize de artifícios como parâmetros de saída (out) ou referência (ref).

Mas existe algo bem mais interessante, que são as tuplas (Tuples). Na prática uma tuple é um array de vários tipos de dados, que podem ser passados ou retornados por um método.

Vamos ao exemplo:

1. Crie um projeto Console no Visual Studio (no meu caso estou usando o 2010, mas você pode usar o 2008 também):

2. Vamos criar um método que retorne vários parâmetros e mostrar o use de Tuple:

   1: class Program

   2: {

   3:    static void Main(string[] args)

   4:    {

   5:       var retorno = RetornaVariosParametros();

   6:  

   7:       Console.WriteLine("Valor inteiro: {0}",retorno.Item1);

   8:       Console.WriteLine("Valor String: {0}", retorno.Item2);

   9:       Console.WriteLine("Valor Double: {0}", retorno.Item3);

  10:    }

  11:  

  12:    public static Tuple<int,string,double> RetornaVariosParametros()

  13:    {

  14:       return Tuple.Create(10, "Tuple", 100.50);

  15:    }

  16: }


Veja como é simples: você usa uma Tuple<> identificando os tipos de dados que ela conterá e depois acessa cada valor através dos Items.

O exemplo é bem simples, mas demonstra a facilidade e a versatilidade das tuplas.

Mais referências sobre Tuple em http://msdn.microsoft.com/en-us/library/system.tuple.aspx

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

Carlos.

Publicando uma aplicação web no IIS 7

Olá pessoal, neste artigo vou mostrar como é simples publicar uma aplicação web no IIS 7 (Internet Information Server), que está presente no Windows Vista, Windows 7 e Windows Server 2008 e 2008 R2.

Publicar uma aplicação na sua rede local ou computador pessoal é um pouco diferente do que publicar em um webhost, que traz ferramentas específicas que ajudam e facilitam o trabalho, visto que dificilmente você terá acesso direto ao IIS do hosting.

Mas no ambiente da sua rede local, será necessário acessar o IIS para publicar sua aplicação web, seja ela Asp.Net, Webservices ou WCF, e é neste caso que este artigo pode lhe ajudar.

Não vou abordar a criação da aplicação propriamente dita, pois existe uma infinidade de artigos na web mostrando técnicas e frameworks que podem lhe ajudar neste processo, aqui vamos abordar simplesmente a publicação e atualização da aplicação.

Então vamos criar uma aplicação bem simples em Asp.Net só para demonstrar a publicação, para isto vá em New Project e escolha Asp.Net e dê o nome de WebTeste:

image

Veja que estamos criando uma aplicação com o Framework 2.0. Estou fazendo isto para demonstrar logo abaixo como podemos publicar uma aplicação com o Framework 4.0, que apresenta algumas diferenças.

Criada a aplicação, vamos apenas escrever um texto qualquer, lembrando que o objetivo é mostrar a publicação apenas:

image

Se você executar esta aplicação, pressionando F5, terá algo como a tela abaixo:

image

O Visual Studio possui um micro servidor web, que serve para ajudar no desenvolvimento de aplicações web, ou seja, com este pequeno servidor, você consegue executar sua aplicação sem precisar instalar o IIS, e para cada aplicação que você executa, ele cria um endereço virtual, como o da imagem acima:

http://localhost:45566/Default.aspx

Isto é bem interessante, pois você pode usar este endereço inclusive dentro da sua rede, ou seja, de um outro computador, se você digitar o nome ou IP deste micro, é possível acessar esta aplicação web, mas lembre-se, somente para o desenvolvimento, pois o Visual Studio compila a aplicação e publica através deste servidor de desenvolvimento.

Mas agora vamos publicar a aplicação corretamente, usando o IIS. Para isto vá no menu Build/Publish do Visual Studio e você verá uma tela igual a este no Visual Studio 2010:

image    image

ou igual a esta no Visual Studio 2008:

image

No Visual Studio 2010, nós temos mais opções na publicação, que você poderá explorar posteriomente. Eu vou escolher publicar em um diretório a nossa aplicação, mas você pode publicar direto no IIS ou por FTP, de acordo com a sua necessidade. Para publicar em um diretório, em Target Location coloque o nome do diretório e depois clique em Publish:

image

Feito isto, o Visual Studio irá compilar e copiar os arquivos necessários para a aplicação web funcionar no diretório especificado, veja:

image

Agora precisamos publicar no IIS, e para isto vamos abrir o Gerenciador do IIS, lembrando que se você não tem o IIS precisará instalá-lo. Abra o gerenciador do IIS clicando Iniciar/Painel de Controle/Ferramentas Administrativas/Gerenciador do Internet Information Services (caso você não veja as Ferramentas Administrativas, use a busca do Painel de Controle) e após isto você vera a tela abaixo:

image

Agora para publicar a aplicação, clique com o botão direito do mouse no site padrão (Default WebSite) e depois em Add Application:

image

Você verá a tela abaixo:

image

Neste tela o Alias é o nome do site, que será usado para acessá-lo pelo navegador e o Physical Path é o diretório onde publicamos a aplicação pelo Visual Studio ou o diretório do seu servidor onde está a aplicação publicada. Clicando em OK, você já poderá acessar a sua aplicação pelo browser:

image

Está pronto, sua aplicação está publicada no IIS 7, mas lembre-se que no eu comentei no início do artigo que para publicar uma aplicação em .Net 4.0 era um pouco diferente e vou mostrar isto agora.

Quando desenvolvemos uma aplicação, ela está ligada a versão do Framework em que foi escrita, e isto acontece também com o Servidor Web (IIS). Nele as aplicações executam sob um Pool de Aplicações, onde você informa qual a versão do framework será executada. Isto possibilita que executemos em um mesmo servidor web aplicações escritas em várias versões do framework. Mas como gerenciar estes Pools  de Aplicação ? Bom isto é bem simples, veja: clicando em Application Pools no gerenciador do IIS você tem esta tela:

image

Ela mostra todos os pools que temos atualmente e você pode notar que temos .Net 2.0 e .Net 4.0, mas não temos o 3.5, pois ele faz parte do 2.0. Vamos então criar e publicar uma aplicação com .Net 4.0, para isto basta primeiramente criarmos a aplicação em  .Net 4.0, então vamos em New Project/Web:

image

Só um detalhe importante é que quando clicamos uma aplicação no Visual Studio 2010 para .Net 4.0, ela já tem um esqueleto pronto, então se você quiser, troque somente o texto da tela inicial, de maneira que fique como a tela abaixo:

image

Depois publique da mesma maneira que foi demonstrado acima. Só para demonstrarmos um erro bem comum, publique a aplicação da mesma maneira que a anterior, e veja que ao executá-la obterá o seguinte erro:

image

Este erro acontece porquê o DefaultAppPool está apontando para o .Net 2.0 e sua aplicação agora é feita em 4.0, vamos então ver a maneira correta de criar a aplicação no IIS. Na verdade os passos são os mesmos com uma pequena diferença, temos que escolher um outro Pool para nossa aplicação, clicando no botão Select da tela de criação de aplicação:

image

Clicando no botão Select, você verá a tela abaixo:

image

Onde escolheremos ASP.NET v4.0, e está pronto, agora você pode acessar sua aplicação sem problemas:

image

Se você já tiver criado a aplicação no IIS e quiser trocar o Pool, basta clicar em Advanced Settings e trocar o Pool. Você pode também criar seu próprio Pool no IIS, clicando com o botão direito em Application Pools/Add Application Pool.

Para finalizar, quando você atualizar a sua aplicação, basta publicar novamente que o IIS irá executar a nova versão.

Se você quer configurar a segurança da sua aplicação, veja estes outros posts:
http://technet.microsoft.com/pt-br/library/cc731278(WS.10).aspx
http://technet.microsoft.com/pt-br/library/cc730708(WS.10).aspx

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

Abraços,
Carlos dos Santos.

Passando parâmetros para uma aplicação .Net

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:

image

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:

image 

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