IntelliSense  Um recurso muito interessante no VS é o IntelliSense, ele ajuda muito durante o desenvolvimento de uma aplicação pois agiliza a digitação de código. Ele apresenta uma lista de opções disponíveis de acordo com o contexto, permitindo selecionar um item de forma muito prática e eliminando a necessidade de memorizar nomes de propriedades, métodos, palavras-chave da linguagem etc.  Por exemplo, ao digitar as iniciais do ID do botão criado no exemplo anterior, o IntelliSense entra em ação apresentando uma lista de sugestõesFigura   12 , ao selecionar o botão e digitar um ponto, uma lista de propriedades do botão será apresentada, conforme a Figura   13 . O recurso também pode ser usado através do pressionamento das teclas CTRL + Espaço. 

PostBack

  Um Postback ocorre sempre que há uma requisição ao servidor Web para

troca de informações. Normalmente, quando clicamos em um botão (existem

outros controles que também podem efetuar Postbacks), informações são

enviadas do browser para o servidor para então serem analisadas. 

 O servidor processa essas informações, gera um novo conteúdo (página) e

devolve ao browser. Por exemplo, imagine uma pesquisa de clientes. Quando

digitamos as iniciais do nome de um cliente em uma caixa de texto e clicamos

em “pesquisar”, o texto que você digitou é enviado ao servidor, o que causa

um Postback. 

 O servidor Web processa essa pesquisa e retorna os dados dos clientes

encontrados na própria página, geralmente em um Grid.

  Para entender melhor como funciona o PostBack, adicione um novo controle

Label e modifique a Propriedade ID para “lblPostback”. 

 Para que o Label apresente se a página executou um PostBack ou não,

vamos utilizar o importante evento Page_Load, que é executado quando a

página é carregada. 

 Para acessar o evento basta dar um duplo clique na página em modo Design.

Codifique o evento conforme a Listagem   4 .

Listagem 4. Verificando se a aplicação executou um PostBack

//Evento que é acionado quando a página é carregadaprotected void Page_Load(object sender, EventArgs e){ //Verifica se é um PostBack   if (IsPostBack)   {      //Caso seja um PostBack ele apresenta       //a mensagem no Label      lblPostback.Text = "outras execuções";                   } else {      //Caso não seja um PostBack ele apresenta       // a mensagem o Label            lblPostback.Text = "Primeira execução";   }            }

Veja que aqui usamos um teste na propriedade IsPostback da página. Ela

funciona de forma simples: se a página está sendo carregada pela primeira vez,

seu valor é falso, se a página está sendo carregada pela segunda vez em

diante, isto é, em resposta a um PostBack (como o clique no botão), seu valor é

true.

 Neste momento se você executar o projeto pela primeira vez o Label vai

aparecer com a mensagem “Primeira execução”. Clique no botão e a página

será enviada e retornará, o PostBack será executado e a mensagem “outras

execuções” será apresentada no Label.

 Vamos criar outro exemplo onde a página vai iniciar apresentando a hora atual,

ao selecionar um item em um componente DropDownList (Figura   14 ) a hora

será atualizada executando o PostBack. O DropDownList é um componente que

permite selecionar um item dentre uma lista de opções.

 

  Adicione-o em nosso projeto da mesma forma que adicionamos os componentes anteriores, localize um botão com o sinal de maior e clique nele (Figura   15 ). Uma janela chamada DropDownList Tasks aparecerá, marque a opção Enable AutoPostBack para deixar automático o PostBack do DropDownList, ou seja, a cada opção da lista que for selecionada a página será enviada e retornará com os dados para serem tratados.Para adicionar opções no componente, clique em Edit Items, clique no botão Add para adicionar alguns itens, digitando na propriedade Text um valor qualquer (Figura   16 .)

Figura 15. Habilitando o AutoPostBack do DropDownList

Figura 16. Inserindo itens no DropDownList

 

   Para que a hora atual seja apresentada na página, adicione um Label com a

propriedade ID igual à lblHora. Vamos utilizar o evento Page_Load novamente

conforme o código na Listagem   5 . Execute o projeto e veja que ao selecionar

um item no DropDownList a hora é atualizada.Observe que aqui usamos o tipo

DateTime para recuperar a hora no servidor. Now representa o momento

atual, enquanto ToLongTimeString formata o texto representando a hora. 

Listagem 5. Atualizando a hora

//Evento que é acionado quando a página é carregadaprotected void Page_Load(object sender, EventArgs e){   //Apresenta a hora no controle Label    lblHora.Text = DateTime.Now.ToLongTimeString();}

Debug  Para finalizar o artigo não poderia deixar de falar de um dos recursos mais

importantes do VS, a depuração do código fonte para encontrar erros e reduzir

o número de bugs no projeto. Localize o código:

  

  lblTitulo.Text = txtNome.Text;

 

  Posicione o cursor no início da linha, aperte a tecla F9, perceba que uma

“bolinha vermelha” chamada breakpoint foi adicionada no lado

esquerdoFigura   17 . Ela indica um ponto onde a aplicação deve parar a

execução, para que dados possam ser analisados.  

  Para executar a aplicação em modo de debug, localize o menu do VS chamado Debug e clique em Start Debugging, ou aperte F5, ou ainda clique

na seta verde  localizada na barra de ferramentas.   Uma mensagem vai aparecer na tela na primeira vez que você executar o debug em uma aplicação, conforme a Figura   18 . Ela informa que o debug não está configurado no arquivo Web.config, apenas confirme.

Digite algo no TextBox, clique no botão e veja que no ponto que inserimos o

breakpoint a linha ficou amarela e apareceu uma seta amarela. Neste

momento podemos analisar a aplicação em execução. 

  Localize no canto direito inferior do VS a janela Immediate Window, nesta

janela podemos visualizar o conteúdo de objetos e até modificar suas

propriedades. Por exemplo, digite txtNome.Text e tecle Enter, na linha de

baixo será apresentado o valor que você inseriu no TextBox. 

  Se você quiser modificar o conteúdo da propriedade Text basta digitar

txtNome.Text = “qualquer texto” e teclar Enter. Aperte a tecla F11 ou localize

no menu Debug o Step Into para avançar a execução linha a linha da sua

aplicação.

  Vamos ver agora outra forma de depurar o projeto. Durante a execução do

debug no canto inferior esquerdo do VS temos a janela Locals e Watch, em

Locals temos todos os objetos utilizando em nossa aplicação e em Watch

podemos inserir os objetos e assistir as mudanças que eles sofrem enquanto

debugamos a aplicação. 

  Para fazer um teste selecione o objeto txtNome junto com a propriedade Text

e com o mouse arraste e solte para dentro da janela Watch, conforme

aFigura   19 . Note que é apresentado o nome, valor e o tipo da propriedade do

objeto. Se você modificar a propriedade Text novamente na janela Immediate

Window o valor ficará em vermelho na janela Watch. Você pode inserir

diversos objetos na janela Watch e monitorar ao mesmo tempo. 

O SQL Server Management Studio  O SQL Server Management Studio inclui ferramentas gráficas para administração de banco de dados em um rico ambiente de desenvolvimento. O Management Studio permite acessar e gerenciar o mecanismo de Banco de Dados, através dele teremos a capacidade de escrever instruções Transact-SQL ou T-SQL (a implementação Microsoft do SQL standard).  Para abrir o SQL Server Management Studio, vá ao menu iniciar escolha Todos os Programas / Microsoft SQL Server 2008e escolha SQL Server Management Studio. Após executado o Management Studio irá apresentar a tela exibida na Figura   11 . Nessa tela temos duas opções, escolher o tipo de autenticação Windows Authentication (o SQL usa o usuário logado no Windows) ou SQL Server Authentication (nativa).   No caso da última opção teremos que informar a senha definida na instalação do SQL Server 2008 Express. Clique em Connect em seguida.

  O Microsoft SQL Server Management Studio é uma ferramenta poderosa e flexível. A Figura   12  mostra sua interface. Podemos observar que existe uma janela, localizada na lateral esquerda, chamada Object Explorer. Essa janela permite a navegação em todos os itens presentes na instância do SQL Server 2008.   Essa janela trará inicialmente uma estrutura do tipo tree view contendo como nó raiz a instância no qual fizemos a conexão. Abaixo dessa instância podemos ver diretórios que agrupam e organizam os demais objetos, tais como: bases de dados, usuários, objetos do servidor, objetos de gerenciamento, entre outros.

  O nosso primeiro passo será criar a nossa base de dados, ou database, que será o nosso repositório para as tabelas do nosso modelo de Blog.  Para isso, clique com o botão direito sobre o item Databases, escolhendo a opção New Database. Será exibida uma janela conforme podemos ver naFigura   13 . Basicamente, precisamos informar o nome da nossa base de dados.   Escreva NetEasyBlog e em seguida clique no botão Ok. Através dessa tela também seria possível definir outras configurações do nosso database, como o tamanho dos arquivos de dados e log, algumas opções de segurança, entre outros.  Contudo, para o nosso exemplo as configurações padrão são suficientes.

 O novo database NetEasyBlog será exibido dentro da estrutura Databases, conforme podemos notar na Figura   14 . Se expandirmos essa estrutura veremos todos os objetos que podemos criar dentro de nossa base de dados. Como dissemos anteriormente, o SQL Server 2008 é uma poderosa plataforma para armazenamento de dados. O SQL Server Management Studio é um ambiente integrado para acessar, configurar, gerenciar e administrar todos os componentes do SQL Server.   Ele combina um amplo grupo de ferramentas gráficas com cinco editores de script avançados para dar acesso ao SQL Server para os desenvolvedores e administradores a todos os recursos da plataforma. Sendo assim, podemos criar, além de tabelas, outros objetos: views, stored procedures, triggers, índices, entre outros.

 

  Faremos agora a criação da nossa primeira tabela. É possível fazermos a criação de forma gráfica, bastando para isso clicar com o botão direito no diretório Tables e em seguida escolher a opção New Table. Preencheremos o painel de criação de tabela conforme descrito na Tabela   2 .   Note que precisamos informar qual o tipo de dado queremos para cada coluna. É importante uma definição correta dos tipos de dados, pois isso influencia diretamente na forma como o SQL Server fará o armazenamento dos registros e também influenciará na performance das consultas.

  O passo seguinte é definir qual é a nossa chave primária (ou primary key), podemos fazê-lo selecionando a linha que contém o campo IdCategoria e clicando com o botão direito sobre a seta indicadora, conforme podemos ver na Figura   15 . Devemos então escolher a opção Set Primary Key. Isso fará com que o SQL Server atribua o campo IdCategoria como chave da tabela Categoria.    Uma vez que definimos um campo como chave o SQL Server cria uma restrição para esse campo, garantindo que um registro seja único. Esse campo não poderá ter o mesmo valor em mais de uma linha.O resultado final da criação da tabela Categoria através da interface gráfica do Management Studio pode ser conferido na Figura   16 . Para salvar a tabela, basta clicar no ícone com um disquete e dar o nome de “Categoria”.

Nota: Observe na janela Properties à direita do Management que definimos a

coluna IdCategoria como sendo a coluna “Identity”. Isso fará com que os

valores para o campo sejam definidos automaticamente pelo BD

(autoincremento).

   A forma como criamos a tabela Categoria não é a única forma

disponibilizada pelo SQL Server Management Studio. Desenvolvedores são

mais familiarizados com a escrita de comandos do tipo DML (Data

Manipulation Language) e DDL (Data Definition Language). Isso porque a

escrita através de comandos dá uma chance de utilizarmos um editor de

textos, o que significa que o código pode ser armazenado ou salvo em

arquivos conhecidos como scripts. 

  Um arquivo de texto utilizado para escrevermos comandos Transct-SQL

salvo através do Management Studio possui a extensão .SQL.Para iniciarmos

o editor de texto do Management Studio podemos utilizar o botão destacado

pela primeira seta da Figura   17 . Uma vez aberto, podemos executar os

comandos Transct-SQL através do botão destacado pela segunda seta

da Figura   17 , ou ainda pressionando a tecla F5.

Figura 17. O botão New Query cria um novo arquivo para escrevermos nossos

códigos Transact-SQL - Executamos nossas queries utilizando o botão destacado, ou pressionando F5

  A mesma tabela Categoria poderia ser criada através de comandos T-SQL conforme mostra a Figura   18 . O comando CREATE TABLE indica que um bloco de comando para criação de uma tabela foi iniciado. Devemos então informar o nome da tabela e em seguida os campos que fazem parte da mesma.   Note que primeiramente informamos o nome da coluna seguido do tipo de dado, e depois informamos a obrigatoriedade do campo (NOT NULL ou NULL). Na linha 6 podemos ver o comando CONSTRAINT que acrescenta uma regra para a tabela, informando ao SQL Server que o campo IdCategoria será a chave primária.

  Outro comando importante é o IDENTITY que define o campo IdCategoria como sendo do tipo autoincremento. Um campo definido como IDENTITY fará o controle do seu valor, incrementando automaticamente o seu valor a cada inserção de novo registro na tabela. Esse é o tipo de campo mais utilizado para chaves-primárias por ser pouco oneroso para o banco em termos de espaço e facilmente indexável.  É importante sempre ficarmos atentos à caixa de seleção destacada naFigura   19 . Ele indicará sobre qual database os comandos serão executados. Devemos escolher o database NetEasyBlog para executarmos os comandos que veremos a seguir. A Listagem   1  exibe todos os comandos necessários para criação das tabelas do database, incluindo a tabela Categoria.

Listagem 1. Script para criação das tabelas da base de dados do Blog

CREATE TABLE [dbo].[Categoria](       [IdCategoria] [int] IDENTITY(1,1) NOT NULL,       [Descricao] [varchar](50) NOT NULL,       [DataCriacao] [datetime] NOT NULL,       CONSTRAINT [PK_Categoria] PRIMARY KEY CLUSTERED        (             [IdCategoria] ASC       )) ON [PRIMARY]GO CREATE TABLE [dbo].[Tag](       [IdTag] [int] IDENTITY(1,1) NOT NULL,       [Descricao] [varchar](30) NOT NULL,       CONSTRAINT [PK_Tag] PRIMARY KEY CLUSTERED        (             [IdTag] ASC       )) ON [PRIMARY]GO CREATE TABLE [dbo].[Autor](       [IdAutor] [int] IDENTITY(1,1) NOT NULL,       [Nome] [varchar](50) NOT NULL,       [Email] [varchar](80) NULL,       CONSTRAINT [PK_Autor] PRIMARY KEY CLUSTERED        (             [IdAutor] ASC       )

) ON [PRIMARY]GO CREATE TABLE [dbo].[Post](       [IdPost] [int] IDENTITY(1,1) NOT NULL,       [Titulo] [varchar](50) NOT NULL,       [Conteudo] [text] NOT NULL,       [DataPublicacao] [datetime] NOT NULL,       [IdAutor] [int] NOT NULL,       [IdCategoria] [int] NULL,       CONSTRAINT [PK_Post] PRIMARY KEY CLUSTERED        (             [IdPost] ASC       )) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]GO CREATE TABLE [dbo].[PostTags](       [IdPost] [int] NOT NULL,       [IdTag] [int] NOT NULL,       CONSTRAINT [PK_PostTags] PRIMARY KEY CLUSTERED        (             [IdPost] ASC,             [IdTag] ASC       )) ON [PRIMARY]GO CREATE TABLE [dbo].[Comentario](       [IdComentário] [int] IDENTITY(1,1) NOT NULL,       [IdPost] [int] NOT NULL,       [NomeLeitor] [varchar](50) NOT NULL,       [EmailLeitor] [varchar](50) NOT NULL,       [DataCriacao] [datetime] NOT NULL,       [Comentario] [varchar](500) NOT NULL,       CONSTRAINT [PK_Comentario_1] PRIMARY KEY CLUSTERED       (             [IdComentário] ASC       )) ON [PRIMARY]GO

Listagem 2. Script para criação das contraints do banco

ALTER TABLE [dbo].[Comentario] ADD         CONSTRAINT [DF_Comentario_DataCriacao]         DEFAULT (getdate()) FOR [DataCriacao]GO ALTER TABLE [dbo].[Post] ADD         CONSTRAINT [DF_Post_DataPublicacao]         DEFAULT (getdate()) FOR [DataPublicacao]GO ALTER TABLE [dbo].[Comentario]         WITH CHECK ADD  CONSTRAINT [FK_Comentario_Post]        FOREIGN KEY([IdPost])       REFERENCES [dbo].[Post] ([IdPost])GO ALTER TABLE [dbo].[Comentario]        CHECK CONSTRAINT [FK_Comentario_Post]GO ALTER TABLE [dbo].[Post]         WITH CHECK ADD  CONSTRAINT [FK_Post_Autor]        FOREIGN KEY([IdAutor])       REFERENCES [dbo].[Autor] ([IdAutor])

GO ALTER TABLE [dbo].[Post]        CHECK CONSTRAINT [FK_Post_Autor]GO ALTER TABLE [dbo].[Post]         WITH CHECK ADD  CONSTRAINT [FK_Post_Categoria]        FOREIGN KEY([IdCategoria])       REFERENCES [dbo].[Categoria] ([IdCategoria])GO ALTER TABLE [dbo].[Post]        CHECK CONSTRAINT [FK_Post_Categoria]GO ALTER TABLE [dbo].[PostTags]         WITH CHECK ADD  CONSTRAINT [FK_PostTags_Post]        FOREIGN KEY([IdPost])       REFERENCES [dbo].[Post] ([IdPost])GO ALTER TABLE [dbo].[PostTags]        CHECK CONSTRAINT [FK_PostTags_Post]GO ALTER TABLE [dbo].[PostTags]         WITH CHECK ADD  CONSTRAINT [FK_PostTags_Tag]        FOREIGN KEY([IdTag])       REFERENCES [dbo].[Tag] ([IdTag])GO ALTER TABLE [dbo].[PostTags]        CHECK CONSTRAINT [FK_PostTags_Tag]GO

  Após executar o script devemos observar a janela Messages do

Management Studio, localizada na parte inferior do editor de textos. 

  Caso o script não contenha erros e não haja algum impedimento (por

exemplo, tabelas já criada), será exibida a mensagem “Command(s)

completed successfully.”.  Uma vez criadas as tabelas, os dados já podem ser inseridos. Contudo devemos antes definir algumas regras para os relacionamentos entre as tabelas.   A Listagem   2  mostra todos os comandos que precisam ser executados para a criação dessas regras. Por exemplo, veja que temos uma constraint entre a tabela Post e a tabela Autor, indicando o relacionamento.

Dica: O comando GetDate, usado no código, retorna a data atual do servidor.

Como resultado teremos o nosso database completo com todas as tabelas

necessárias para o Blog. Podemos conferir o resultado no diagrama exibido

na Figura   20 . Este diagrama pode ser criado no Management Studio clicando

com o botão direito na janela Object Explorer no item DatabaseDiagrams e

escolhendo a opção New Database Diagram. 

  A Figura   21  mostra a janela Add Table, onde podemos adicionar as tabelas que deverão fazer parte do diagrama.

Fazendo uso do banco de dados  Agora estamos habilitados a utilizar o nosso banco de dados. Faremos algumas inclusões e alguns testes, utilizando comandos do tipo DML (Data Manipulation Language). Abra um novo arquivo de script e insira alguns dados, utilizando como referência a Listagem   3 .  A Figura   22  mostra os registros que serão inseridos na database. 

Listagem 3. Inserindo alguns registros nas tabelas

INSERT INTO Tag (Descricao) VALUES (Programação)INSERT INTO Tag (Descricao) VALUES (Linguagens)INSERT INTO Tag (Descricao) VALUES (Tutorial)GO INSERT INTO Categoria (Descricao, DataCriacao) VALUES(SQL Server, GETDATE())INSERT INTO Categoria (Descricao, DataCriacao) VALUES(.NET Easy, GETDATE())GO INSERT INTO Autor (Nome, Email) VALUES (Lendro Daniel, contato@leandrodaniel.com)GO INSERT INTO Post (Titulo, Conteudo, DataPublicacao,IdAutor, IdCategoria)VALUES (Tutorial SQL Server 2008 Express, Conteúdo do post, GETDATE(), 1, 1)GO INSERT INTO PostTags (IdPost, IdTag) VALUES (1, 1)INSERT INTO PostTags (IdPost, IdTag) VALUES (1, 3)GO INSERT INTO Comentario (IdPost, NomeLeitor, EmailLeitor,DataCriacao, Comentario) VALUES (1, Bruno Daniel, bruno@mail.com, GETDATE(), Post interessante!)INSERT INTO Comentario (IdPost, NomeLeitor, EmailLeitor,DataCriacao, Comentario) VALUES (1, Peg Sue, peg@mail.com, GETDATE(), Good!)GO

 Veremos agora algumas situações onde as constraints garantirão a consistência das informações.

Execute a query a seguir e observe que um erro será exibido no painel Messages (essa query não

será executada com sucesso como consequência da criação da constraint que garantem a

consistência das informações armazenadas):

DELETE Categoria

 

Msg 547, Level 16, State 0, Line 1

A instrução DELETE conflitou com a restrição do REFERENCE "FK_Post_Categoria". O conflito

ocorreu no bando de dados "NetEasyBlog", tabela "dbo.Post", column IdCategoria.

A instrução foi finalizada.

 

 

  Isso ocorre porque definimos um relacionamento entre a tabela Categoria e Post que impede que

registros da tabela Categoria sejam apagados caso haja algum relacionamento de uso pela tabela

Post.

  A seguir vemos outro exemplo de query que não seria executada com sucesso, pois não existe

uma Tag com o ID  = 6:

 

INSERT INTO Post (Titulo, Conteudo, DataPublicacao, IdAutor, IdCategoria)

VALUES (Tutorial Management Studio, Conteúdo do post, GETDATE(), 1, 6)

 

UMA INTRODUÇÃO AO WINDOWS FORMS

Para que serve

Aplicativos desktop são a maioria no

ambiente Windows, muito utilizados na

área comercial e automação. Dessa

forma, este artigo serve para introduzir

o leitor no uso da tecnologia através da

criação de um exemplo simples.

 

Em que situação o tema é útil

Este artigo é focado para o público

iniciante em aplicações Windows

Forms com o .NET. Traz informações

úteis para quem está aderindo a esta

plataforma e precisa saber quais

devem ser os componentes e suas

propriedades envolvidas na criação de

uma aplicação.

 Aplicações Desktop, conhecidas até pouco tempo como aplicações Win32,

dominaram o mercado de automação comercial. Aplicações desenvolvidas

com Visual Basic ou Delphi ofereciam (e oferecem) ao usuário enormes

recursos para realização de seus processos, de forma fácil, rápida e, porque

não dizer bela, com telas muito bem elaboradas. Com a chegada do Windows

Vista, os desenvolvedores (os mais antigos claro) começam a reviver algo que

passaram há uma década, quando manter uma aplicação D.O.S. executando

em um ambiente Windows começava a ficar cada vez mais difícil. 

  Até quando aplicações Win32 executarão perfeitamente em um ambiente

Windows atualizado? A plataforma .NET é, sem dúvida alguma, a melhor

opção, também, para ambientes desktop, através de suas aplicações

Windows, com seus Windows Forms.

  Note que desenvolver uma aplicação com Windows Forms, não significa

dizer que ela é exclusivamente para Desktop, ela pode ser apenas uma

interface que trabalha através de Web Services para recuperação e

manutenção de dados. Quanto à linguagem, é possível escolher Visual Basic,

Delphi ou C#, dentre outras. É claro que há uma mudança, de certa forma

radical, de paradigma, principalmente no que diz respeito ao acesso a dados. 

  Este artigo apresenta uma introdução ao desenvolvimento de uma aplicação

desktop, trazendo os componentes necessários para a criação de uma janela

principal para uma aplicação, assim como diferenciação entre interfaces SDI e

MDI para aplicações com janelas.

Aplicações MDI, SDI e TBI

  MDI (Multiple Document Interface) é uma característica de aplicações que

possuem suas janelas sempre “amarradas” a uma janela principal. Esta janela

principal também é conhecida como MDI Parent, MDI Container, Parent

Window ou Parent Form. Em português encontram-se traduções na literatura

como Janela Pai ou Proprietária. SDI (Simple Document Interface) já tem uma

característica diferenciada, onde toda janela é independente, não ficando

limitada a sua exibição à área cliente disponibilizada pela Parent Window. Já o

TBI (Tabbed Document Interface) é uma característica que surgiu nos últimos

anos, através dos browsers, que começa a ser utilizada em aplicações

desktop também. A Tabela   1  apresenta exemplos das características MDI,

SDI e TBI.

  Antes de apresentar a implementação de aplicações SDI ou MDI, será

trabalhada a criação da aplicação em si, mas é importante ter estes conceitos

em mente. 

Criando e configurando o projeto  Acesse o Visual Studio e crie uma nova solução selecionando os menus File

> New Project > Other Project Types > Visual Studio Solutions e escolha a

opção Blank Solution. Uma solução pode conter nela vários projetos. Pode-se

pensar em ter uma solução com um projeto para a camada de apresentação,

um para a camada de negócios e um para a camada de persistência por

exemplo.

 No Solution Explorer (Ctrl-Alt-L) clique com o botão direito do mouse sobre o

nome da solução criada.

Nota: Caso a solução não apareça selecione os menus Tools > Options >

Projects and Solutions e marque a opção Always show solution.

  No menu popup exibido escolha a opção Add > New Project. Na linguagem

Visual C# escolha a opção Windows e então Windows Forms Application. O

projeto é criado com um formulário vazio (Form1.cs). Elimine-o, pressionando

a tecla Del com o arquivo selecionado. 

Criando uma janela principal para a aplicação  A maioria das aplicações possui uma janela, onde as opções da mesma são

exibidas, por menus ou barras de ferramentas. Desta forma, vamos criar uma

janela que cumpra este objetivo. Clique novamente com o botão direito do

mouse, agora sobre o nome do projeto e escolha a opção Add > Windows

Form e dê a este novo formulário o nome FormJanelaPrincipal.cs. Será

preciso configurar algumas propriedades para este formulário.     

  Tenha certeza de estar com o formulário selecionado e pressione F4 para

visualizar a guia Properties. Siga a Tabela   2 . Após estas configurações, abra

o arquivo Program.cs no Solution Explorer e altere o nome Form1 para

FormJanelaPrincipal. Salve seu projeto e pressione F5 para execução de sua

aplicação. Seu formulário deverá ser exibido ocupando toda a área de

trabalho, não deverá permitir mudar seu tamanho, estará exibindo o ícone

escolhido ao lado esquerdo da barra de títulos e também o título informado.

 

Criando menus,barra de tarefas e de status  Uma vez criado e configurado o formulário responsável pela janela principal,

é preciso inserir neste formulário os meios de acesso às opções da aplicação. 

  Na Toolbox (Ctrl+Alt+X), na categoria Menus & Toolbars selecione e arraste

para o formulário o componente ToolStripContainer e você terá em sua janela

algo semelhante ao apresentado pela Figura   1 .

  O ToolStripContainer é um componente composto de cinco painéis que

podem ser utilizados também como containers, nas bordas são dispostos

instâncias de ToolStripPanel e na área central um ToolStripContentPanel. A

ideia é que nas bordas sejam inseridos menus, barras de tarefas e barras de

mensagens, compondo assim uma janela padrão de aplicações desktop. O

ToolStripContainer permite que os painéis das bordas aceitem docking, ou

seja, que controles possam ser postos neles.

  A visibilidade dos painéis por default é ativa, como mostra o popup da

SmartTag da Figura   1 . É possível alterar estes valores também por código e

na janela de propriedades (F4) através das propriedades

TopToolStripPanelVisible, BottomToolStripPanelVisible,

LefToolStripPanelVisible e RightToolStripPanelVisible.

  A área central do ToolStripContentPanel tem o objetivo de receber o

conteúdo a ser apresentado ao usuário, desta forma, a ideia é que este painel

ocupe realmente toda a área disponibilizada pela janela, desta forma, clique

no link Dock Fill in Form que aparece na SmartTag ou configure a propriedade

Dock dele para Fill, como mostra a Figura   2 . Após estas configurações feitas

sua janela deve estar semelhante à apresentada pelaFigura   3 .

Nota: SmartTag (ou Tasks), vista na Figura   2 , é uma janela suspensa que o

VS apresenta com opções comuns para configuração de um controle.

Figura 2. Configurando o dock do ToolStripContainer

Figura 3. ToolStripContainer ocupando toda a área da janela

Dica: É possível verificar através do apresentado pela Figura   3  que nem todas

as bordas têm os painéis expandidos, mas isso é facilmente resolvido clicando

no botão que existe no centro de cada borda. Clicando neste botão ele recolhe

e expande o painel.

  É preciso agora adicionar ao ToolStripContainer um menu, uma barra de

tarefas e uma barra de mensagem/status. Isso é possível através dos

componentes: MenuStrip, ToolStrip e StatusStrip respectivamente. Estes

componentes estão na mesma categoria que o ToolStripContainer na

ToolBox. Arraste primeiro o MenuStrip para o TopStripPanel, depois, para o

mesmo Panel, arraste o ToolStrip e para finalizar, arraste para o

BottomStripPanel o StatusStrip.

  Vamos agora configurar os controles inseridos no ToolStripContainer,

começando pelo MenuStrip. Ao clicar no componente MenuStrip é exibido um

container com o texto Type Here. Neste local é possível inserir um tipo de item

ao menu, como ToolStripMenuItem (que é o padrão para os menus),

ComboBox ou um TextBox. Usaremos o ToolStripMenuItem. Para isso, basta

digitar o título do menu na caixa em que é solicitado.  Digite “Cadastros” e

note que é aberto abaixo do novo item de menu campos para menus

suspensos. Crie um item do menu suspenso chamado “Clientes” e outro

“Fornecedores”.    

  Ao lado do menu Cadastros crie um outro chamado “Relatórios” e abaixo

dele “Contas a Receber” e “Contas Pagar”.

Para inserir botões a sua barra de tarefas clique na mesma e será exibido a

você um ComboBox. Expandindo este componente é exibida uma relação de

vários componentes possíveis de serem inseridos em sua barra de tarefa. 

Tabela 3. Configuração do Button da barra de tarefas

  Vale a pena testar cada um deles, porém nos concentraremos no Button.

Insira um Button em sua barra de tarefas e veja na Tabela   3  as propriedades

a serem configuradas.

  Insira na barra de tarefas outro Button, agora com o ToolTipText “Acesso ao

relatório de contas a pagar”. Para inserir um componente à barra de status o

processo é o mesmo utilizado para a inserção na barra de tarefas. A variação

de componentes possíveis é um pouco inferior, mas a investigação é

igualmente interessante.Neste exemplo será feito uso do StatusLabel. As

propriedades a serem configuradas para este componente são apenas duas:

(Name) com o valor lblStatus e Text que deve ficar vazia. Neste momento sua

tela deve estar semelhante à apresentada na Figura   4 .

Figura 4. Janela principal com strips inseridos e configurados

  Clique na barra de tarefas, sobre a linha de pontos vertical e arraste a barra

de tarefas para as laterais da janela, veja que elas acabam se fixando nas

laterais, sem que você tenha tido a necessidade de escrever nenhuma linha

de código. Este comportamento, porém, pode não ser o desejado por você.

Para proibir este tipo de comportamento, clique na Smart Tag da ToolStrip e

atribua o valor Hidden para GripStyle, como mostra a Figura   5 .

Figura 5. Desabilitando o Grip

Criando novos formulários  Crie em seu projeto um novo formulário, da mesma forma que fizemos anteriormente, dê a ele o nome FormClientesCRUD.cs, configure o formulário de acordo a Tabela   4 .  Com as mesmas configurações apresentadas na Tabela   4 , crie agora outro formulário, chamado FormFornecedoresCRUD.cs, alterando apenas o valor da propriedade Text, mudando a palavra Clientes para Fornecedores. 

Tabela 4. Configuração do formulário FormClientesCRUD

Implementando o acesso aos formulários através da janela principal  Existem dois tipos de janelas quando se trabalha com aplicações desktop, as janelas do tipo Modal e as não modais (Modalless). As modais são aquelas em que o acesso às janelas que estejam atrás delas é “negado”, até que esta janela seja fechada. Já as janelas Modalless são janelas que podem ser exibidas e a ativação de uma delas pode ser feita sem a necessidade de se fechar a que esteja ativa no momento.

 

  No formulário principal, acesse o item de menu Clientes, dentro de Cadastros

e na janela de Propriedades, na guia Events, dê duplo clique na caixa em

branco ao lado do evento Click. No editor de códigos, digite o código

apresentado pela Listagem   1 . Siga o mesmo procedimento para o acesso à

Janela de Fornecedores (o código é visto na Listagem   2 ).

Listagem 1. Evento Click do menu de acesso ao cadastro de clientes 

private void clientesToolStripMenuItem_Click(object sender, EventArgs e){FormClientesCRUD formClientesCRUD = new FormClientesCRUD();formClientesCRUD.Show();}

Listagem 2. Evento Click do menu de acesso ao cadastro de fornecedores 

private void fornecedoresToolStripMenuItem_Click(object sender, EventArgs e){FormFornecedoresCRUD formFornecedoresCRUD = new FormFornecedoresCRUD();formFornecedoresCRUD.Show();}

  Teste sua aplicação (pressione CTRL + F5) e acesse os formulários através

dos menus. Veja que mesmo com uma janela aberta é possível acessar o

menu na janela principal e acessar uma outra janela. Caso você acesse a

mesma janela é preciso saber que da forma que o código está implementado,

o formulário será instanciado a cada vez que se deseja acessar e isso pode

ser custoso. 

  Como este exemplo trabalha com janelas Modalless é interessante alterar

esta implementação. O primeiro passo é declarar uma variável que represente

a classe do formulário (um atributo à classe) e então, quando for acessar o

formulário, verificar se a janela já não foi instanciada antes de chamá-la, como

é apresentado pelo código implementado pela Listagem   3 .

Listagem 3. Alteração na chamada a uma janela através do menu

private FormClientesCRUD formClientesCRUD; private FormFornecedoresCRUD formFornecedoresCRUD; private void clientesToolStripMenuItem_Click(objectsender, EventArgs e){if (formClientesCRUD == null)      formClientesCRUD = new FormClientesCRUD();      formClientesCRUD.Show();} private void fornecedoresToolStripMenuItem_Click(objectsender, EventArgs e){if (formFornecedoresCRUD == null)      formFornecedoresCRUD = new FormFornecedoresCRUD();      formFornecedoresCRUD.Show();} 

Dica: Há situações em que não seja permitido que o usuário acesse outra

janela da aplicação enquanto não terminar uma atividade específica. Sendo

assim é preciso proibir que ele acesse as janelas atrás da atual. Isso é muito

simples, basta que ao invés de se chamar o método Show() seja chamado o

método ShowDialog().

Mudando de SDI para MDI

  No exemplo criado anteriormente, uma janela criada, como a de Clientes, é

vista como uma janela independente. Faça um teste, altere no formulário da

janela principal a propriedade WindowState para Normal, execute sua

aplicação e chame as janelas criadas (Clientes e Fornecedores). Veja que as

janelas são independentes e podem ser arrastadas para qualquer parte da

área de trabalho (Desktop). Essa é a característica de aplicações SDI e isso

em algumas situações pode não ser uma boa política. Desta forma, vamos

alterar a aplicação para que faça uso dos recursos de uma aplicação MDI.

  O primeiro ponto é saber que o controle ToolStripContainer não pode ser

utilizado em aplicações MDI, desta forma os strips devem ser colocados

diretamente no formulário e perde-se a capacidade de ancoragem dos strips

nas laterais da página, mesmo visualizando o Grip nas strips. Retire o

ToolStripContainer de sua janela principal ou crie uma outra. Para não perder

as barras e menus criados, mova-os para fora do ToolStripContainer de modo

que fiquem associados ao formulário.

Para o formulário principal, configure especificamente a propriedade

daTabela   5 .

 Observe a atribuição “formClientesCRUD.MdiParent = this” abaixo da criação

do objeto. Esta atribuição define como janela pai do formulário criado o

formulário atual, que neste caso é a janela principal. A última linha tem a

responsabilidade de desabilitar o item do menu do respectivo evento, para que

o usuário não possa criar novamente a janela antes que ela seja fechada. 

  Execute sua aplicação e procure mover a janela de clientes dentro da

principal e você verá que ela não sai dos limites da área cliente, ocultando a

parte que não couber nos limites, como mostra a Figura   6 .

  Veja que ambas as janelas ficam abertas e visíveis, permitindo a visualização

de mais de uma janela ao mesmo tempo e isso é realmente muito bom.

Uma vez acessado um formulário, sua opção de menu é desabilitada, como

visto pelo código das Listagens 4 e 5, desta forma, é preciso pensar em como

tornar o menu ativo novamente e, isso pode ser feito no momento em que a

janela é fechada, como mostra a implementação da Listagem   6 .

  Veja que o código da Listagem   6  traz a implementação para o evento

FormClosed do formulário de clientes. Este código obtém o primeiro menu do

MainStripMenu definido na janela principal (MdiParent), que é o Cadastro e

então é obtido o primeiro item de menu, que é Clientes e então este item é

tornado habilitado novamente. É importante que a propriedade MainMenuStrip

do formulário que representa a janela principal tenha atribuído a ela o menu

principal.

  Mas como chamar novamente uma janela que já foi aberta e teve sua opção

de acesso via menu, desabilitada, sem ter que fechar esta janela para

novamente habilitar o menu? O próximo item trata esta situação e algumas

outras.

Listagem 6. Habilitando menu para criação de janela

private void FormClientesCRUD_FormClosed(object sender, FormClosedEventArgs e){(MdiParent.MainMenuStrip.Items[0] as ToolStripMenuItem)      .DropDownItems[0].Enabled = true;}

Criando um menu para as janelas ativas em uma aplicação MDI  Em algumas aplicações MDI é comum verificar como último menu na barra um menu chamado Janela ou Window. Neste menu aparece uma relação de todas as janelas ativas e opções para organizar as mesmas dentro da Janela MDI parent. Crie um novo menu ao lado do de Relatórios, dê a ele o nome mnuJanelas e na propriedade Text informe o valor Janelas (ou Window). Agora, selecione o MenuStrip e na propriedade MdiWindowListItem selecione este novo menu criado. Execute sua aplicação, abra os dois formulários de cadastro e clique no menu Window, ele deverá estar semelhante ao apresentado pela Figura   7 .

 

 Em aplicações MDI, onde várias janelas abertas ao mesmo tempo ficam

todas dentro da região destinada a elas no Parent Form, é preciso poder

organizar estas janelas. Inclua no menu Window (ou Janela) as opções

Cascata, Lado a Lado e Fechar Janela Atual (veja que existe um separador

antes da última opção, para inseri-lo, coloque um hífen na propriedade Text),

como mostra a Figura   8 .

 A implementação para os itens criados no menu apresentado

pelaFigura   8  pode ser vista na Listagem   7 . Para criar os manipuladores para

os eventos mostrados, você pode simplesmente dar um duplo clique sobre os

itens de menu, isso equivale a acionar a janela de propriedades e dar um

duplo clique no lado do evento Click.

Dica: Você pode configurar o Click dos botões da barra de tarefas para

simplesmente apontarem para os mesmos métodos dos itens de menu, para

não reescrever código. Para isso, basta selecionar o botão, ir até os eventos

na janela de Propriedades e escolher na caixa suspensa do evento Click o

respectivo método.

  Execute sua aplicação, abra os dois formulários, vá no meu Window (ou

Janela) e teste as novas opções. Existem outras possibilidades de layout, que

certamente você notou ao digitar o texto.

Listagem 7. Código para organização das janelas

private void cascataToolStripMenuItem_Click(objectsender, EventArgs e){LayoutMdi(MdiLayout.Cascade);} private void ladoALadoToolStripMenuItem_Click(objectsender, EventArgs e){LayoutMdi(MdiLayout.TileVertical);} private void fecharToolStripMenuItem_Click(object sender,EventArgs e){ActiveMdiChild.Close();}

PRIMEIROS PASSOS COM A LINGUAGEM C#

Para que serve

Os fundamentos do C# e seus

elementos básicos são usados em

qualquer tipo de aplicação, quer seja

um simples programa de console,

como os que serão apresentados

neste artigo, a aplicações Windows

Client (Windows Forms, WPF etc.),

aplicações Web, Web Services etc. Em

todos estes tipos de programas os

elementos básicos do C# são usados

intensivamente e o seu conhecimento

desde o início facilita o trabalho do

programado

Em que situação o tema é útil

Muitas vezes aparecem situações nas

tarefas de programação em que um

problema aparentemente simples de

se resolver começa a dar mais

trabalho do que o esperado. Isto se

deve muitas vezes a uma falta de

conhecimento mais profundo dos

elementos básicos de uma linguagem

de programação. Com os elementos

apresentados aqui, espera-se que

algumas tarefas sejam simplificadas e

tragam ao desenvolvedor uma

produtividade maior, podendo servir de

referência para consultas posteriores.

 

Os programas de computador são ferramentas usadas para resolver

problemas do dia-a-dia para as pessoas. Podemos escrever um programa em

um 100 número de linguagens, cada uma delas tendo suas regras próprias,

seu controle de fluxo de programa, seus tipos de dados suportados e classe

de programa que mais se apropria a resolver.

  Com o lançamento do framework .NET pela Microsoft, uma nova linguagem

surgiu: o C#. Esta linguagem que tem características parecidas com outras

linguagens como C++ e Java, é uma linguagem orientada a objetos que

permite que todas as classes do framework .NET sejam usadas e

consequentemente todos os recursos desta plataforma estejam acessíveis ao

programador.

  É possível escrever vários tipos de aplicações com C# quer sejam

programas de console, que é o ponto de partida para este artigo, até

aplicativos mais complexos como Web Services, aplicações Web entre outros.

Uma vez que o C# está vinculado com o framework .NET, o ponto mais

importante é conhecer as classes e recursos desta plataforma, o que não

dispensa o programador de conhecer as particularidades da linguagem.

  Para fazermos nosso estudo iremos utilizar o Visual Studio 2008. Faremos

uso de aplicações console para poder focar mais na linguagem do que na

criação de elementos da interface, sendo que estes poderão ser tratados em

uma ocasião futura visto que a criação de interfaces com o usuário é um

assunto extenso. Aos poucos, iremos expondo os principais elementos da

linguagem e acrescentando complexidade através de códigos de exemplo.

Criando um programa no Visual Studio

  Os programas no Visual Studio são tratados como projetos. Cada programa

deve ser criado como um projeto em separado. Vários projetos podem ser

agrupados dentro de uma solução (Solution). Vamos começar criando uma

solution na qual criaremos nossos projetos.

  Abra o Visual Studio e através dos menus File > New > Project (Figura   1 ),

abra a janela para criar uma nova solution. Observe na Figura   2  as

configurações feitas para criar a nova solution.

Figura 1. Criando um novo projeto

Figura 2. Janela para criação do novo projeto

 Uma vez escolhidas as opções, o Visual Studio exibe uma tela para que seja escrito o código já com o primeiro modelo de programa console que podemos usar.   A Figura   3  demonstra como ficou o modelo ao terminarmos de criar o projeto.

 Se você nunca usou o Visual Studio vou destacar alguns elementos

importantes nesta interface:

- Aba de edição de arquivo: localizada abaixo das barras de ferramentas, esta

aba mostra todos os arquivos da solução que estão abertos. Geralmente um

programa pode ter vários arquivos, cada um sendo usado para armazenar

uma classe, formulário ou porção específica do código. Você pode alternar

entre estas páginas através do teclado usando CTR+TAB;

- Janela Solution Explorer: mostra todos os projetos componentes da solution

e também os arquivos e pastas que fazem parte da mesma. Funciona como

uma janela do Windows Explorer, sendo que muitas opções estão disponíveis

ao clicar sobre um elemento com o botão direito do mouse.

  Um programa do tipo console em C# não irá possuir elementos de interface

com o usuário, sendo esta feita através de uma janela do prompt de

comandos do Windows. Então, vejamos a estrutura básica deste programa

na Listagem   1 .

Listagem 1. Estrutura básica de um programa console

1 using System;2 using System.Collections.Generic;3 using System.Text;4 5 namespace CSharpFundamentos6 {7    class Program8    {9       static void Main(string[] args)10       {11       }

12    }13 }

 A linguagem C# é orientada a objetos. Logo, tudo o que fizermos nela será

feito usando os conceitos deste tipo de programação. Mesmo quando estamos

fazendo um simples programa de console, usaremos classes e o programa

em si precisará ser definido dentro de uma classe.

  Neste programa estamos importando os principais namespaces do

framework através das instruções using que devem ser incluídas no começo

do programa. Existem muitos destes namespaces e cada classe deverá fazer

uso de elementos específicos. Para começarmos o nosso programa o Visual

Studio já incluiu aqueles que são os mais comuns. Podemos deixar como

está. 

  O nosso programa possui ele próprio um namespace indicado logo abaixo

dos usings. Este elemento pode ser omitido em programas mais simples, mas

existem casos como, por exemplo, quando formos criar uma biblioteca de

classes (class library) que usualmente é representada pelos arquivos DLL do

Windows, em que o uso de namespaces facilitará a organização separando as

classes conforme sua funcionalidade.

Como foi dito, cada programa em C# é ele próprio uma classe então, logo

abaixo da indicação do namespaces, colocamos a identificação da classe.

Finalmente, como se trata de uma aplicação do tipo console, precisamos ter o

método principal que se torna o “ponto de entrada” do programa. Isto é

indicado através da criação de um método (função da classe) do tipo estático

(static) que não faz nenhum tipo de retorno (void) nomeado como Main, este

nome deve ser seguido sempre que criarmos método principal de uma

aplicação console.

 Um ponto fundamental da linguagem C# é que ela é case sensitive, ou seja,

faz diferenciação entre maiúsculas e minúsculas logo: using é diferente

de Using e main não será considerado ponto de entrada do programa sendo

necessário seguir a sintaxe Main. Nos exemplos que forem colocados neste

artigo observe cuidadosamente este detalhe.

Exibindo dados no console

  Uma primeira tarefa a ser feita é possibilitar exibição de dados no programa

para o usuário. C# possui várias formas de fazer isto, na Tabela   1 seguem os

principais métodos, todos eles da classe Console. Escreva o programa

da Listagem   2  para verificar o funcionamento destes métodos.

Tabela 1. Métodos para entrada de dados pelo console

Listagem 2. Escrevendo no console

1 using System;2 using System.Collections.Generic;3 using System.Text;45 namespace CSharpFundamentos6 {7    class Program8    {9       static void Main(string[] args)10       {11          // posiciona o cursor12          Console.SetCursorPosition(0, 0);13          // escreve o texto na posição14          Console.Write("Canto Superior Esquerdo");15          Console.SetCursorPosition(55, 0);16          Console.Write("Canto Superior Direito");17          Console.SetCursorPosition(0, 24);18          Console.Write("Canto Inferior Esquerdo");19          Console.SetCursorPosition(56, 24);20          Console.Write("Canto Inferior Direito");21          // interrompe a execução do programa22          // aguarda o pressionamento do ENTER23          Console.ReadLine();24       }25    }26 } 

  O programa posiciona o cursor do console em uma posição e escreve um

texto ali. Após fazer isso, interrompe a execução do programa e aguarda até

que seja pressionada a tecla ENTER para que quando estiver sendo

executado a partir do Visual Studio pela tecla F5, seja possível visualizar o

conteúdo da janela do programa. A sua execução deve resultar em algo

parecido com o da Figura   4 .

Uma tarefa muito comum em programas do tipo console é ler alguma informação que foi passada pelo usuário e exibir esta na tela. A Listagem 3dá um exemplo disto. Altere o seu programa e execute para que possamos a partir deste, vermos outros elementos da linguagem C#. 

9  static void Main(string[] args)10 {11    Console.Write("Informe o seu nome por favor: ");12    // muda a cor de fundo do texto13    Console.BackgroundColor = ConsoleColor.White;14    // muda a cor do texto15    Console.ForegroundColor = ConsoleColor.Black;16    // recebe uma entrada de texto e armazena17    string Nome = Console.ReadLine();18 19    Console.ResetColor();20    Console.WriteLine("Usuario conectado: {0}", Nome);21    Console.ReadKey();22 }

  No exemplo da Listagem   3  apresentamos um texto para o usuário

solicitando que ele digite o nome, na linha seguinte (13), para darmos um

efeito diferente mudamos a cor de fundo do console e a cor do texto. Em

seguida, armazenamos a entrada do console em uma variável do tipo “string”

através da instrução Console.ReadLine. Na linha seguinte, retornarmos as

cores originais do console e apresentamos o conteúdo da variável “Nome” na

tela. O resultado do programa deve ser parecido com o da Figura   5 .

Nota: Observe na Linha 17 da Listagem 3 a sintaxe de declaração de uma

variável no C#:<tipo> nomevariavel = valor inicial

 Note que na instrução “Console.WriteLine”, escrevemos uma mensagem e

concatenamos o texto inserindo um parâmetro representado pelas chaves “{}”

e um algarismo. Com o C# é possível fazer concatenação de dados para uma

saída através do uso de uma expressão seguindo o seguinte padrão:

Console.WriteLine(“<string> {parâmetro<0>} {parâmetro<1>} …

    {parâmetro<n>}”, parâmetro<0>, parâmetro<1>, ... parâmetro<n>)

Entenda da seguinte forma:

- As aspas indicam que dentro delas é definida a mensagem a ser exibida;

- Para mostrar valores de parâmetros, coloque dentro das aspas o número do

parâmetro (iniciando sempre em zero) envolvido pelas chaves “{}” e, após

fechar a string com as aspas, coloque os parâmetros no mesmo número que

foi incluído dentro da string.

Vamos dar continuidade aos nossos estudos no C#, examinando agora os

operadores da linguagem.

Operadores de atribuiçãoOperadores de atribuição são usados para armazenar um valor para as variáveis de memória. O mais comum e utilizado é o de igualdade (=), como podemos conferir na linha 13 da Listagem   3 . A Tabela   2  mostra outros operadores.

Listagem 3. Lendo dados do usuário

9  static void Main(string[] args)10 {11    Console.Write("Informe o seu nome por favor: ");12    // muda a cor de fundo do texto13    Console.BackgroundColor = ConsoleColor.White;14    // muda a cor do texto15    Console.ForegroundColor = ConsoleColor.Black;16    // recebe uma entrada de texto e armazena17    string Nome = Console.ReadLine();18 19    Console.ResetColor();20    Console.WriteLine("Usuario conectado: {0}", Nome);21    Console.ReadKey();22 }

Operadores matemáticos  Os operadores matemáticos são usados para executar operações aritméticas no C#. Veja a lista na Tabela   3 .

Armazenando os dados - tipos de variáveis

  Todos os programas terão pelo menos dois elementos fundamentais: dados

a serem processados e a lógica de processamento destes dados. A lógica de

processamento consiste no algoritmo a ser usado para a resolução do

problema propriamente dito, já os dados representam valores a serem

manipulados.

Em todas as linguagens de programação os dados são armazenados na

memória através de variáveis. No C# isto ocorre da mesma forma, sendo que

existem dois grandes tipos de variáveis conforme o tipo de armazenamento

feito: tipos armazenados por valor e por referência.

  Tipos armazenados por valor ou Value Types são aqueles em que o dado é

armazenado diretamente na memória. Ao se criar uma cópia destes dados,

cria-se outra variável sem vínculo nenhum com a variável anterior.

Já os tipos por referência fazem uma referência a um endereço da memória

onde os dados são armazenados e ao copiarmos o conteúdo de uma variável

para outra, estes ficam interligados e modificações feitas em uma variável

alteram o valor da cópia desta.

Tipos por valor

  Os tipos de dados por valor do C# são os dados nativos como aqueles

usados para armazenamento de números inteiros e de ponto flutuante e tipos

definidos por usuários como as structs. Na Tabela   4  temos exemplos de tipos

números de valor. Observe nessa tabela que temos o tipo nativo do .NET

Framework (tipo) e o equivalente em C# (Sintaxe C#), que funciona como um

“alias”.

 Com relação aos tipos de dados numéricos, um ponto importante a ser

observado é a faixa de dados que é a capacidade de armazenamento

suportada pelo tipo. Normalmente, um tipo de dados com faixa de dados

superior, pode receber um valor vindo de uma variável com capacidade

inferior. Por exemplo, uma variável do tipo “int” pode receber valores de uma

variável do tipo “short”, mas o contrário não pode ser feito sendo gerado um

erro de programação, conforme a Listagem   4  demonstra. Ao tentar compilar o

programa o erro da Figura   6  é exibido.

Tabela 4. Tipos de dados numéricos do C#

Figura 6. Mensagem de erro ao tentar compilar o programa

  O mesmo acontece se quisermos armazenar um valor de uma variável do

tipo inteiro em uma variável de ponto flutuante como, por exemplo, double ou

float. Logo, observe a capacidade de armazenamento de cada tipo ao utilizar

tipos numéricos em C#.

A inicialização de tipos numéricos de ponto flutuante deve ser feita

adicionando os sufixos “M” para inicializar tipo decimal e “F” para float (veja

um exemplo na Listagem   5 ). Caso isto não seja feito o compilador irá

apresentar uma mensagem de erro. O código gera os erros de compilador

mostrados na Figura   7 .

  Na Tabela   5  podemos ver mais alguns tipos de dados passados por valor. 

Figura 7. Erro ao inicializar incorretamente ponto flutuante

Tabela 5. Tipos de dado por valor (continuação)

Tipos de dado por referência

  São tipos de dados em que a variável armazena o endereço da memória em

vez do dado propriamente dito. Com isso, ao copiar o conteúdo de uma

variável para outra, teremos na verdade duas variáveis apontando para um

mesmo endereço da memória o que fará com que, ao se alterar o conteúdo de

uma variável, o mesmo aconteça com suas cópias. 

 Existem milhares de tipos por referência nativos no framework.

A Tabela   6 lista algum dos mais comuns. Vejamos na Listagem   6  o que

acontece ao criarmos cópias de dados em variáveis por referência.

Tabela 6. Alguns tipos passados por referência

  Estamos usando StringBuilder para criar um objeto que armazena várias strings e retorna uma string final com o método “.ToString()”. Ao criarmos a variável sb1 e adicionarmos um valor para ela, estamos referenciando um endereço de memória.  Quando copiamos seu conteúdo para a variável sb2, o conteúdo de sb1 é copiado para ela, o que já era esperado, entretanto, na linha 22 nós adicionamos um novo valor apenas para a variável sb1. Mas, ao exibirmos o conteúdo das duas variáveis, note que sb2 ficou com o mesmo conteúdo de sb1. Veja o resultado na Figura   8 . 

Figura 8. Executando testes com variáveis por referência

Modificadores de acesso

  Em C# a visibilidade de uma variável pode ser alterada para que seja

possível acessá-la dentro e fora da classe, apenas dentro da classe ou

apenas para o executável / assembly atual. Isto é feito com os modificadores

de acesso private, public e internal (existem outros como protected).

  Uma variável definida como private só vai poder ser acessada dentro da

classe em que foi criada. Já uma variável com o modificador de acesso public

é acessada de qualquer ponto do programa, até mesmo fora da classe em

que foi criada. Já uma variável com o modificador internal só pode ser

acessada dentro do assembly em que foi criada. No exemplo

daListagem   7  criamos uma classe com campos públicos e privados. Essa

classe é um tipo que representa uma Pessoa, que tem um identificador, um

nome e uma data de nascimento (falaremos mais sobre classes adiante). 

  Em seguida, criamos uma instância desta classe no programa, o que

chamamos de “funcionario”. Ao pressionarmos o ponto “.” para visualizarmos

quais campos estão visíveis (Figura   9 ), notamos que somente aqueles

marcados como public estão disponíveis para serem usados.Um ponto

importante nos modificadores de acesso é que se não declararmos o tipo de

acesso, private é assumido como o padrão. Para maiores detalhes na criação

de classes, veja o tópico “Classes em C#”.

Figura 9. Visualizando campos "public"

 

Inicialização de variáveis - tipos implícitos

  A partir da versão 3.0 do C# não é mais obrigatório que se declare o tipo de

uma variável ao se inicializá-la. Isto pode ser feito com o inicializador dinâmico

“var” e o tipo da variável fica implícito conforme o tipo do valor que foi

armazenado pela variável.

  Observe que usando “var” após a inicialização das variáveis, o próprio

IntelliSense do Visual Studio já assume o tipo correto apresentando métodos e

propriedades relacionados com o tipo de dado armazenado (Figura   10 ). Este

recurso também é conhecido como “Type Inference”.

  Isto pode ser feito com qualquer tipo de inicialização de dados desde que

seja possível para o C# deduzir qual o tipo do dado que será armazenado na

variável.

Figura 10. Usando "var" e inspecionando o tipo - Na figura, o compilador sabe

que “nome” é uma string

Tipos de dados definidos pelo usuário -

Struct

  Em alguns casos é necessário armazenamento de dados complexos como,

por exemplo, dados de endereço de uma pessoa. Pode-se fazer isto através

do uso de um tipo chamado de struct em C#. Deve-se definir quais os campos

irão fazer parte da variável.  A Listagem   8  exemplifica o uso de uma struct.

 Uma struct é bem parecida com uma classe, uma vez que temos que criar

uma variável para poder acessar os seus membros, porém, este é um tipo por

valor enquanto a classe é um tipo por referência. Neste exemplo criamos um

struct para armazenar dados de um funcionário. Estamos definindo todos os

campos como públicos para serem visíveis ao criarmos uma instância. Ao

fazermos isso na linha 18, precisamos em seguida atribuir valores para os

campos criados. Para criarmos um valor para o campo de data de nascimento,

que é do tipo data, usamos um construtor que passa como parâmetros o ano,

o mês e o dia. Em seguida, fazemos a exibição destes dados. Note que

estamos fazendo uma formatação destes dados. 

  Por exemplo, para formatar a data usamos a expressão “dd/MM/yyyy” e para formatar o salário “n2”, o resultado deste programa pode ser conferido naFigura   11 .

  Nota: Para você conhecer mais sobre formatação de string, consulte mais sobre o tópico “String.Format” no framework .NET. Existem inúmeros formatos de dados que podem ser úteis quando necessitar exibir números, datas ou qualquer outro dado formatado.

Classes em C#

  As classes na linguagem C# têm uma grande importância assim como em

qualquer linguagem orientada a objeto. Será com elas que você irá

desenvolver as soluções para os problemas que seus programas irão resolver.

Neste artigo, vamos aprender como criar uma classe com seus elementos

básicos. Existem várias considerações que serão omitidas neste artigo tais

como, por exemplo, o uso de interface e também herança.

As classes são definidas com a palavra chave class precedida do seu tipo de

acesso: public, private ou internal. Os campos (atributos, propriedades etc.) e

métodos devem ser criados sendo precedidos pelo modificador de acesso e

também o tipo de dado do campo ou de retorno do método. Para métodos que

não retornam nenhum valor usa-se a palavra o tipo “void” (vazio).

  Uma classe pode ter construtores parametrizados onde, valores iniciais são

passados para a classe, um construtor padrão, sem nenhum parâmetro, ou

ambos. Podemos também invocar um construtor padrão a partir de um

construtor parametrizado, fazendo com que uma inicialização feita pelo

construtor sem parâmetros possa ser invocada quando utilizarmos os

construtores parametrizados. Na Listagem   9  temos um exemplo de uma

classe.

Nota: Observe que no C# o nome do construtor leva o mesmo nome da

classe.

  Neste código criamos os campos com os modificadores de acesso

apropriados. Também fizemos dois construtores: um deles não recebe

nenhum parâmetro e inicializa a variável ID, o outro recebe parâmetros para

as demais variáveis porém, não inicializa o campo ID. Fazemos a inicialização

deste campo invocando o construtor padrão através do uso de this, como está

destacado no código na linha 29. Se formos consumir esta classe no nosso

código podemos fazer de várias formas, vejamos a tradicional conforme

a Listagem   10 .

  Note que não há nenhuma diferença entre este código e o que foi usado para a struct. Entretanto considere o código da Listagem   11 . A partir deste exemplo, já instanciamos a classe passando os parâmetros que serão usados como está representado a partir da linha 41. Com isso, usamos a segunda versão do nosso construtor, parametrizada.  Entretanto, com a versão 3.0 do C#, outro tipo de inicialização de classes mais resumido e sofisticado tornou-se possível. Altere a classe para que fique sem o inicializador parametrizado, conforme a Listagem   12 .  Em seguida, vamos instanciar a classe, mas nomeando as variáveis públicas e passando os valores para eles. Não é necessário obedecer a ordem de criação, embora esteja em ordem no código (Listagem   13 ). Isto pode ser feito com todas as classes dentro do framework 3.0, certamente é uma maneira bem mais clara de se inicializar um objeto. Este recurso também é conhecido como “Object Initializer”. 

Valores nulos

  Um tipo especial de variáveis dentro do C# são aquelas que recebem valores

nulos, ou seja, aquelas que ainda não foram inicializadas. Algumas variáveis

como as numéricas possuem valores padrão como zero no caso destas.

Entretanto, existem tipos de dados que não possuem um valor padrão ficando

seu conteúdo na memória como nulo até serem inicializados.

  Considere por exemplo um formulário de entrada de dados de uma aplicação

Windows onde um usuário deve digitar algum valor. Enquanto ele não digitar

nada, o valor estará vazio, ou seja, não terá nada. Em alguns casos é

necessário considerar valores nulos mesmo para variáveis que originalmente

não suportam este tipo de dado. Isto é feito em C# usando-se a palavra chave

“nullable<tipo do dado>” ou incluindo-se um “?” ao lado do tipo do dado.

Exemplo:

nullable<int> Var;

ou

int? Var;

 

  Neste caso antes de fazer comparações com os dados, precisamos certificar

que o campo possui algum valor. Somente quando a variável puder receber

valores nulos isto poderá ser feito, verificando-se a propriedade HasValue:

 

// Verifica se a variável possui valor

if (Var.HasValue)

{  // algum código aqui

...

}

Arrays

  Arrays ou vetores são uma coleção de valores do mesmo tipo de dados. Eles

são criados no C# declarando-se o tipo da variável seguido de colchetes “[]”.

Da mesma forma, para acessar o atribuir os valores de um elemento do array,

colocamos entre os colchetes o número do índice do elemento dentro deste.

Declarando um “array” de strings:

                              

string[] aNomes;

 

Opcionalmente, podemos declarar a dimensão do “array”:

 

string[10] aNomes;

 

  Neste caso precisaremos inicializar manualmente cada índice, lembrando

que em C# sempre iniciamos a contagem com zero no indexador (número

entre os colchetes) e o último elemento do array será igual a dimensão do

“array” menos um. O código da Listagem   14  demonstra a criação de um array

de números inteiros de cinco posições.

 

 

   Uma outra forma é criar o array e inicializar seus valores diretamente:

int[] nums = { 123, 0, 199, 9, 4};

 Os arrays que criamos até aqui são unidimensionais, ou seja, possuem

apenas uma coluna e um valor para cada elemento. É possível criar-se arrays

bidimensionais com C# da seguinte forma:

 

int[,] nums;

nums[0,0] = 1;

                nums[0,1] = 2;

 Neste caso, o primeiro indexador refere-se à linha e o segundo à coluna do

vetor.

Controle de repetições de instruções

  Faça uma revisão nos vetores (arrays) que criamos até aqui. Se quisermos

inspecionar o valor de cada elemento do vetor temos que percorrer todos os

valores. Isto pode ser feito de várias formas no C# usando-se os controles de

repetição de instrução do C# que são:

- While

- Do while

- For

- Foreach

While  É usado sempre que quisermos que uma porção de código seja executada

enquanto uma determinada condição for satisfeita. Sua sintaxe básica é a

seguinte:

while( <condição>)

{

          <instruções>

}

 

  Veja um exemplo na Listagem   15 .A partir da linha 12, inicializamos o vetor e

em seguida a variável que será usada para indexar os elementos. A condição

para a execução é que seja executado até a variável “i” ser menor “<” do que

o tamanho do vetor. Observe que para sabermos o tamanho do array (número

de elementos que ele possui) acessamos a propriedade Length.

Do While  Neste tipo de controle de fluxo, a instrução é executada pelo menos uma vez

e então a condição para que seja executada é verificada.

do

{

         <instruções>

                 } while ( <condição> );

  Vemos um exemplo de uso na Listagem   16 . Note que basicamente inverteu-

se o loop que fizemos com o while, jogando esta palavra chave para o final do

loop. Por causa disto, deve-se tomar cuidado com o incremento da variável

que controla os elementos para que não ultrapasse o limite máximo do vetor.

 

For  Com este tipo de loop, estabelece-se um indexador, uma condição para que

ele seja executado e seu incremento:

  

 

for (<declaração da variável de índice>; <condição>;

<incremento>)

{

          <instruções>

}

 

  Na Listagem   17  temos um exemplo de uso do For. 

Foreach  Com este loop a execução é mais simplificada ainda, pois não se usa um

indexador. Por esse motivo, as chances da haver um erro são menores, pois

não há como o programador por descuido ultrapassar os limites do array. A

sintaxe básica do foreach é a seguinte:

foreach(<tipo> <variavel> in <array>)

{

         <instruções>

                 }

  Na Listagem   18  temos um exemplo de uso do Foreach.

 

Controle de fluxo condicional do programa  Os seguintes elementos permitem que o controle do fluxo do programa seja

feito conforme condições específicas:

- if-else - switch

  If-else é o controle de fluxo mais comum usado, basicamente deve se

colocar a condição a ser avaliada dentro do parênteses seguida do código a

ser executado. Em seguida, a palavra chave else seguida do bloco de códigos

a ser executado, caso seja necessário especificar um comando a ser

executado caso a expressão não seja verdadeira. O código

daListagem   19  verifica se um número é par ou ímpar através do operador

módulo “%”, que retorna o resto de uma divisão por um determinado número.

  Existe uma outra maneira de fazer isso usando o “if in line”, a sintaxe básica

é a seguinte:

(<condição> ? Valor se verdadeiro : Valor se falso)

 O código da Listagem   19 , adaptado para usar este recurso, fica como

naListagem   20 .

Operadores relacionais

  A Tabela   7  mostra os operadores quepermitem executar comparações e

verificar condições no C#.

  Além destes, existem os operadores lógicos que podem ser usados para

acrescentar verificações nas comparações ou condições para execução do

programa (Tabela   8 ).

Operador switch

  Em C# existem casos que múltiplas verificações do valor de uma variável

devem ser feitas. Neste caso, vejamos como faríamos isso com “if-else”

(Listagem   21 ). Porém esta forma de executar testes lógicos se torna

extensa. 

  Como alternativa, para quando múltiplos valores podem ser atribuídos a uma

variável, podemos usar o bloco switch, onde colocamos no switch o valor que

será inspecionado e para cada case, uma possibilidade de valor, seguido das

instruções finalizando o bloco com “break” (Listagem   22 ).

 

Para cada valor encontrado, escrevemos um código após o case. Se nenhum

valor for encontrado, usamos o bloco default para fazer o tratamento. Uma das

vantagens deste bloco é que podemos fazer um único código para múltiplas

opções. Vamos imaginar que seja informado o país “UK” (Reino unido) que

também fala o idioma inglês, ou ainda os países “ESP” (Espanha) ou “PY”

(Paraguai), que também falem o idioma espanhol, para isso basta inspecionar

os valores e deixar o bloco de código em branco, agrupando todos eles da

forma como segue na Listagem   23 .

ASP.NET PARA DESENVOLVEDORES DESKTOP

Para que serve

Serve para orientar de forma correta e

imparcial desenvolvedores Desktop a

iniciarem seus trabalhos na Web com

ASP.NET reaproveitando os

conhecimentos que já possuem.

 

Em que situação o tema é útil

Hoje ter uma solução baseada na

Internet deixou de ser uma opção ou

vantagem, é uma obrigação. Este

artigo será útil para orientar empresas

e desenvolvedores nos cuidados

necessários ao iniciar os trabalhos no

desenvolvimento Web com ASP.NET.

 Há um bom tempo empresas e desenvolvedores detectaram que possuir uma

versão Web de seus produtos Desktop seria uma excelente opção. Estavam

completamente certos. A Web se tornou o novo padrão para desenvolvimento

dos mais variados tipos de aplicações. Entretanto, muitas empresas

preferiram não arriscar na nova onda do mercado, muito tendo em vista

preocupações tecnológicas. Qual a melhor tecnologia para desenvolvimento

Web se eu e minha equipe já possuímos um bom know-how no

desenvolvimento Desktop? Hoje aquela opção se tornou dor de cabeça para

muitos, pois não ter um sistema na Web ou pelo menos parte dele é um

problema, um grande problema. Deixou de ser opção, é uma obrigação.

  Nesse sentido vemos hoje uma infinidade de profissionais à procura de

material e aperfeiçoamento para portar ou migrar completamente sistemas

Desktop para ambiente Web, ou mesmo iniciar seus novos projetos na

plataforma Web, aproveitando seu vasto conhecimento adquirido durante anos

de desenvolvimento para Windows. Muitos pontos devem ser levados em

consideração neste caso, sair migrando tudo de uma única vez é certamente

um risco. Aplicações Desktop terão sua serventia por muitos e muitos anos

ainda. Principalmente aplicativos comerciais continuarão a rodar na plataforma

Windows, esse é o melhor caso, por exemplo, para aplicativos de frente de

caixa e softwares de automação.

  Há muitos anos a Web realmente tinha suas limitações, as tecnologias de

desenvolvimento eram literalmente arcaicas. Nos primórdios da Internet,

basicamente o que tínhamos eram páginas estáticas com conteúdo textual e

algumas imagens, normalmente através da utilização de HTML puro.A Internet

começou a se tornar dinâmica com a inclusão das linguagens servidoras. Por

exemplo, a tecnologia CGI permitiu incluir dados dinâmicos em páginas, como

dados vindos de um banco de dados. 

Hoje a história é outra. Temos um leque muito grande de opções para o

desenvolvimento de aplicativos Web. Tecnologias, linguagens, ambientes de

desenvolvimento e frameworks facilitam a criação de softwares baseados na

Internet. E quem sempre desenvolveu para Desktop, e nunca pôs a mão em

uma linha de código em ambiente Web, qual a melhor opção? Aqui entra o

ASP.NET.

ASP.NET como opção para desenvolvedores Desktop  O ASP.NET revolucionou o mercado de desenvolvimento para Web quando surgiu, por permitir o desenvolvimento de aplicações de forma visual, o que é comum para desenvolvedores que utilizam o ambiente Desktop. Usando o Visual Studio, desenhamos um formulário (Web Form) arrastando controles para a tela, o que chamamos de desenvolvimento drag & drop (arrastar e soltar).   Os controles servidores do ASP.NET são os principais responsáveis pela facilidade do desenvolvimento visual. Os ASP.NET Server Controls encapsulam a geração de código HTML e permitem um desenvolvimento orientado a objetos, usando boas práticas de programação. O desenvolvedor não precisa se preocupar em conhecer detalhes específicos da plataforma Web, como geração de código HTML para rodar no browser, tratamento de requisições HTTP, uso de protocolos de baixo nível etc. Desenvolvemos da mesma forma que estávamos acostumados no Desktop.

  Controles ASP.NET têm propriedades, métodos e eventos, assim como

componentes utilizados em ambiente Desktop. Se pararmos para pensar

como isso era feito antes, lembraremos das “Actions” no servidor, que eram

usadas para recuperar informações não tipadas diretamente de formulários

Web, manipular HTML, gerar novas tags e devolver um novo conteúdo. Tudo

isso misturado em um único arquivo. No ASP.NET, configuramos

propriedades visualmente, programamos no servidor usando uma linguagem

de alto nível, podendo desfrutar de todos os recursos da orientação a objetos. 

   O que quero dizer com tudo isso? O ASP.NET é sem dúvida alguma a

melhor opção para o desenvolvimento Web para quem já tem prévios

conhecimentos com linguagens de desenvolvimento Desktop. E mesmo para

quem nunca desenvolveu qualquer tipo de aplicação, o ASP.NET também se

mostra uma excelente opção: 

é produtivo, intuitivo, robusto, fácil, com excelente documentação e recursos

disponíveis para seu aprendizado, está em constante evolução (é muito

importante apostar em uma tecnologia que você sabe que não vai nascer e

morrer da noite par o dia), possui uma grande comunidade ao redor do mundo

e muito mais. 

   Este artigo não é um tutorial prático nem tem por objetivo desenvolver um

exemplo completo, mas permita-me mostrar um paralelo claro do que estou

querendo dizer. Uma das aplicações mais famosas que sempre vi durante

meus estudos em uma das linguagens mais populares para o

desenvolvimento Desktop, o Delphi, consistia do formulário da (Figura   1 ).

  Note os controles usados, um Edit, um ListBox e um Button. Este formulário

foi criado visualmente, nada de programação, simplesmente arrastamos os

controles para dentro do designer. A função dele é adicionar no ListBox os

itens digitados no Edit, quando o botão for clicado.

  O código do evento OnClick do botão pode ser visto aqui:

procedure TForm1.Button1Click(Sender: TObject);

begin

  ListBox1.Items.Add(Edit1.Text);

end;

 

  E na Web? Exatamente igual, não existe diferença alguma. Duvida?

Arrastamos os mesmos controles para o designer do Visual Studio, digitamos

o mesmo código e rodamos (Figura   2 ). Claro, aqui não temos Edit, temos o

TextBox. Talvez seja a maior curva no aprendizado deste exemplo. O código a

seguir mostra a implementação do Click do botão, em C#:

 

protected void Button1_Click(object sender, EventArgs e)

{

    ListBox1.Items.Add(TextBox1.Text);

} 

Figura 1. Uma aplicação Desktop tradicional de exemplo

Figura 2. Uma aplicação Desktop tradicional, agora na Web

  A propósito, também é possível desenvolver para ASP.NET usando o Delphi

Prism com o Visual Studio, exatamente da mesma forma, o código é:

method Default2.Button1_Click(sender: System.Object; e: System.EventArgs);

begin

    ListBox1.Items.Add(TextBox1.Text);

end;     É claro, o .NET framework tem um conjunto de classes bastante vasto, existem inúmeras opções para realizar uma tarefa (um exemplo claro são as diversas formas de acesso a banco de dados). Além disso, muitos programadores Desktop sentem maiores dificuldades não na utilização de uma linguagem ou ambiente diferente (pois são muito parecidos), mas na quebra de paradigma Web versus Desktop. Costumo dizer que, muitas vezes, é mais difícil migrar uma mente do que um código. Partindo disto, vamos examinar alguns cuidados, dicas e técnicas para você não ter problemas ao iniciar seus trabalhos no ASP.NET. 

Dicas para um bom desenvolvimento Web  Em primeiro lugar, tenha em mente que uma página não é um formulário do

Windows. Na Web, muitas coisas que fazemos com tranquilidade no Desktop exigem um pouco mais de esforço. Às vezes, eu realmente sugiro que você não tente imitar sua aplicação Desktop e fazê-la idêntica em ASP.NET. Isso é um risco! Tentar tornar uma página do browser tão rica quanto uma interface Windows é um sonho, no qual já existem soluções que estão em evolução e aperfeiçoamento, portanto, não reinvente a roda. Como tecnologias nesse sentido podemos citar o ASP.NET AJAX e o Silverlight.

 Um outro ponto importante no desenvolvimento Web é performance. No

Desktop, muitos não se preocupam com a correta alocação e liberação de

recursos, total, se você deixar escapar uns 4 bytes em um clique de um botão

“Gravar”, provavelmente ao final do dia o usuário vai desligar o Windows e o

computador e tudo é liberado “à moda antiga”. Já na Web, 4 bytes perdidos

em uma requisição podem se tornar 4 Gigabytes consumindo a memória do

servidor ao final de um dia. Aplicações Web não são “desligadas”. ASP.NET é

state-less, e isso ajuda, significa que muita coisa é liberada entre uma

requisição e outra. Além disso, o .NET conta com um poderoso mecanismo de

coleta de lixo que libera recursos não mais utilizados. Mas tenha em mente,

você vai usar muito mais o try finally (ou using) a partir de agora.

  Lembre-se que na Web milhares de usuários podem acessar sua aplicação

em um mesmo instante, por esse motivo, ela é por padrão multithread. Tenha

cuidado com cada byte que você aloca na memória do servidor, saiba

gerenciar bem o estado de cada variável, saiba utilizar corretamente sessões.

No desktop, cada usuário roda uma única instância da sua aplicação por vez.

Na Web serão milhares rodando no mesmo servidor. Quer um exemplo de

como isso é uma preocupação importante? Sendo curto, objetivo e prático,

abra mil instâncias do Delphi ou do Visual Studio na mesma máquina e verá o

que quero dizer.

Gerenciamento de estado - Este é certamente o ponto de maior dificuldade ao

iniciar os trabalhos na Web. No Desktop, você aloca um objeto e deve liberá-lo

após seu uso. Na Web, tudo é perdido após cada requisição (em tecnologias

state-less como o ASP.NET), como comentei anteriormente. Realmente

gerenciar sessão é algo que não existe no Desktop, então procure começar

seus estudos por este ponto, pois ele é crítico. Os controles servidores

ASP.NET já nos ajudam bastante mantendo seu próprio estado entre

requisições. No exemplo que apresentei antes, como os dados foram sendo

persistidos no ListBox enquanto eu os adicionava? Pode parecer uma questão

idiota, mas era para não funcionar, o ListBox deveria exibir somente o último

item adicionado. Graças ao recurso de ViewState, o ASP.NET nos poupa de

controlar estado para os controles do servidor. Porém o resto é com você, tenha

isso em mente.

  Postbacks - Esteja bem preparado, pois aqui mora uma das principais

diferenças na migração. Quando você clica em botão no Desktop, uma

mensagem da API do Windows é trocada internamente, e tratada pelo

framework que você utiliza, normalmente através de um evento. No ASP.NET

existe o mesmo conceito (de eventos), porém lembre-se que há um Postback,

uma nova requisição é criada, várias informações são trocadas entre cliente e

servidor.

  Além disso, procure conhecer profundamente todos os recursos que o

ASP.NET e o .NET como um todo oferecem para aumentar  a performance de

aplicações Web, em especial: 

- Conexão a banco - a consulta ao banco de dados é o recurso mais precioso e

que mais consome tempo em ambiente Web. No desktop abrimos uma conexão

e a mantemos aberta durante toda a aplicação, se for uma aplicação client-

server provavelmente o SGBD vai ter no máximo umas 50 conexões

simultâneas. Na Web isso é extremamente diferente. Aqui temos que abrir uma

conexão, o mais rápido possível executar os comandos SQL e fechar a

conexão. Deixe que o ADO.NET (tecnologia de acesso a dados) cuide d

resto. Ele possui mecanismos, como Connection Pooling, que vão garantir a

performance; 

- Use Stored Procedures, elas aumentam consideravelmente a performance

do servidor;

- Use e abuse (mas com cuidado) do objeto Cache, principalmente para

colocar resultados de consultas do banco de dados em memória e dispensar

futuras conexões. Por exemplo, se você tem uma tabela que é

constantemente consultada, porém não sofre tantas alterações, traga os

dados para Cache e a partir daí não vá mais ao banco;

- OutputCache - excelente recurso que permite que a saída em HTML gerada

pelo ASP.NET possa ser colocada em memória. Futuras requisições ao

servidor não realizam nenhuma tarefa adicional, como processar o código C#

ou Delphi Prism, ou renderizar a página, ou consultar o BD. O ASP.NET

simplesmente devolve o HTML pronto e ponto final. Voa.

- Não tente simular algo como DataModules em ambiente Web. Aqui a regra

é: execute algo, coloque em tela o resultado e feche tudo;

Além desses cuidados básicos, procure sempre usar boas prática de

desenvolvimento em suas aplicações Web, através da Programação

Orientada a Objetos, Design Patterns, Testes, Refactoring, Desenvolvimento

em Camadas etc. Separe bem a responsabilidade de cada classe, use

herança, esconda implementações complexas (use interfaces e classes

abstratas).

Isso facilitará a manutenção futura da sua aplicação, além de torná-la mais

adaptável a uma possível mudança técnica futura sem causar um impacto

gigantesco em toda a solução (por exemplo, a troca do tipo de servidor de

banco de dados ou da tecnologia de acesso a dados). Aproveite os recursos

do Visual Studio, como Code Analysis, recursos para arquitetura (novo no

VS2010), testes integrados, para sempre deixar sua aplicação com qualidade. 

 

.

<div>&nbsp;&nbsp; Triplique seus cuidados com segurança. Lembre-se que na .

Web seu aplicativo estará acessível ao mundo inteiro. Conheça os principais tipos de ataque a servidores, defina boas políticas de segurança ainda na fase de análise do projeto. E lembre-se, o ASP.NET lhe dará um boa mão nesse sentido, pois muitos detalhes de implementação estão prontos.</div>&nbsp;&nbsp; E finalmente, tenha muito cuidado ao optar por tecnologias que são usadas em conjunto com o ASP.NET. Se sua equipe está iniciando o desenvolvimento na Web, tenha em mente que há uma curva de aprendizado que pode ser um risco. Opte por tecnologias mais consolidadas, bem testadas, com maior documentação e garantia comprovada. Por exemplo, desenvolvedores Desktop normalmente não estão acostumados a utilizar frameworks de persistência e mapeamento objeto relacional. Sair usando logo no primeiro dia de projeto o NHibernate ou o ADO.NET Entity Framework pode ser custoso, principalmente se o prazo for uma preocupação. Ambos são excelentes frameworks, e aqui vai uma dica caso queira considerar o seu uso em projetos futuros: desenvolva em camadas, assim, mais adiante você pode substituir sua camada de acesso facilmente sem modificar outros módulos do sistema.

Vantagens do desenvolvimento Web que não existem no Desktop  Agora que já vimos que o ASP.NET é a solução ideal para os desenvolvedores Desktop, vamos só lembrar de alguns aspectos que por tabela você ganha ao colocar sua solução na Web: - Deployment - na Web, você instala seu software em um Data Center, um servidor nas nuvens, seus clientes não precisam nada mais do que um browser. Nada de instalar aplicativos em dezenas de máquinas, configurar arquivos, pastas, bibliotecas etc. Uma atualização do software pode ser feita no servidor, e todos os clientes passam a enxergá-la;

- Se você ainda é uma daquelas pessoas que discute qual é o melhor sistema operacional, se Windows, Linux, Mac OS, Google Chorme OS, esqueça. Ao desenvolver com ASP.NET, você hospedará seu sistema em um servidor dedicado e tudo o que seu cliente precisa é de um browser, rodando em qualquer sistema operacional. Pode até mesmo usar um iPhone, ou um SmartPhone com Windows Mobile (ou futuramente o Windows Phone 7), e acessar dados da aplicação Web de qualquer parte do planeta, sem instalar nada;- Manutenção - Nada de se preocupar com backups dos clientes, visitas presenciais, envio de mídias com o software, downloads, vírus etc. Isso são características de sistemas Desktop. Aproveite, as dores de cabeça com esses problemas acabam ao ter seus sistema nas nuvens;

O que vem por aí?  Hoje estamos diante de um dos maiores lançamentos mundiais na área de desenvolvimento: o Visual Studio 2010, juntamente com o ASP.NET 4.0 e .NET 4.0, confirmado para 12 de Abril de 2010. Procure se manter informado sobre as novidades, acompanhe as evoluções tecnológicas e o novos recursos que esta versão trará. No ASP.NET, destaco o aprimoramento do suporte ao AJAX, o que vai tornar suas aplicações Web cada vez mais parecidas com seu software Desktop.

Conclusão

  Este artigo procurou motivar você, desenvolvedor Desktop, a optar pela

tecnologia ASP.NET para seus novos projetos Web. Comprovamos que o

ASP.NET é sem dúvida alguma a opção mais robusta do mercado para este

propósito, e a que exigirá uma menor curva de aprendizado. Vimos também

muitos cuidados que você deve ter ao começar a escrever software que

rodará nas nuvens. Cuidados com performance, segurança, gerenciamento de

estado, que são tão importantes quanto os requisitos impostos pelo seu

cliente. Abra o Visual Studio, crie uma nova aplicação ASP.NET e sinta-se em

casa. Sucesso nos novos projetos, grande abraço e até o próximo artigo.