Aplicações WEB

Visual Studio não depura quando se faz Attach a um programa

2012-01-14T10:00:00.000-02:00

Ao tentar fazer um “Attach to Process” a um aplicativo em execução para depurá-lo, pode-se não habilitar os breakpoints. A causa mais comum é se não tiver o arquivo PDB(que tem informações de depuração) disponível no diretório. Se for seu caso, basta compilar sua solução e disponibilizar junto com o aplicativo o arquivo pdb e tentar depurar novamente.

Agora, se você tiver o PDB já no diretório atente-se ao output do Visual Studio, se há alguma mensagem como abaixo:

‘Aplicativo.exe' (Managed (v4.0.30319)): Loaded 'C:\caminho\Bin\Arquivo.dll', Skipped loading symbols. Module is optimized and the debugger option 'Just My Code' is enabled.

Para conseguir depurar, basta habilitar a opção abaixo:

Referência

https://login.live.com/login.srf?wa=wsignin1.0&wtrealm=social.msdn.microsoft.com&wreply=https%3a%2f%2fsocial.msdn.microsoft.com%2fForums%2fen-MY%2fvsdebug%2fthread%2fe55d2f23-4803-45a9-995d-77b461e23273%3fstoAI%3d10&wp=MBI_FED_SSL&wlcxt=microsoft%24microsoft%24microsoft

Introdução ao JSON com C#

2012-01-12T20:07:00.001-02:00

JavaScript Object Notation é um padrão para troca de informações. É fácil para homens ler e escrever e maquinas podem facilmente entender e gerar. Esse padrão é baseado no JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999. JSON é um formato de texto que é independente de linguagem, mas usa convenções familiares a família C.

JSON é construído em 2 estruturas:

1 – Uma coleção de pares de chave(string)/valor(string, number, object, array, true, false, null)

2 – Uma lista ordenada de valores

Uma grande vantagem do JSON é que ele tem pouca verbosidade, ainda mais quando se comparado com WebService por exemplo. Vários aplicativos online, que precisam disponibilizar informações de forma simples, fazem comunicações por JSON, como exemplo há o foursquare.

Veja um exemplo de um JSON válido

Um exemplo simples de leitura JSON no C#

Crie um projeto Console e adicione referência a System.Runtime.Serialization

Adicione o código abaixo no arquivo Program.cs, fazendo alterações necessárias ao namespace:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Runtime.Serialization;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            GoogleSearchResults g1 = new GoogleSearchResults();
            const string json = @"{""responseData"": {""results"":[{""GsearchResultClass"":""GwebSearch"",""unescapedUrl"":""http://www.cheese.com/"",""url"":""http://www.cheese.com/"",""visibleUrl"":""www.cheese.com"",""cacheUrl"":""http://www.google.com/search?q\u003dcache:bkg1gwNt8u4J:www.cheese.com"",""title"":""\u003cb\u003eCHEESE\u003c/b\u003e.COM - All about \u003cb\u003echeese\u003c/b\u003e!."",""titleNoFormatting"":""CHEESE.COM - All about cheese!."",""content"":""\u003cb\u003eCheese\u003c/b\u003e - everything you want to know about it. Search \u003cb\u003echeese\u003c/b\u003e by name, by types   of milk, by textures and by countries.""},{""GsearchResultClass"":""GwebSearch"",""unescapedUrl"":""http://en.wikipedia.org/wiki/Cheese"",""url"":""http://en.wikipedia.org/wiki/Cheese"",""visibleUrl"":""en.wikipedia.org"",""cacheUrl"":""http://www.google.com/search?q\u003dcache:n9icdgMlCXIJ:en.wikipedia.org"",""title"":""\u003cb\u003eCheese\u003c/b\u003e - Wikipedia, the free encyclopedia"",""titleNoFormatting"":""Cheese - Wikipedia, the free encyclopedia"",""content"":""\u003cb\u003eCheese\u003c/b\u003e is a food consisting of proteins and fat from milk, usually the milk of   cows, buffalo, goats, or sheep. It is produced by coagulation of the milk \u003cb\u003e...\u003c/b\u003e""},{""GsearchResultClass"":""GwebSearch"",""unescapedUrl"":""http://www.ilovecheese.com/"",""url"":""http://www.ilovecheese.com/"",""visibleUrl"":""www.ilovecheese.com"",""cacheUrl"":""http://www.google.com/search?q\u003dcache:GBhRR8ytMhQJ:www.ilovecheese.com"",""title"":""I Love \u003cb\u003eCheese\u003c/b\u003e!, Homepage"",""titleNoFormatting"":""I Love Cheese!, Homepage"",""content"":""The American Dairy Association\u0026#39;s official site includes recipes and information   on nutrition and storage of \u003cb\u003echeese\u003c/b\u003e.""},{""GsearchResultClass"":""GwebSearch"",""unescapedUrl"":""http://www.gnome.org/projects/cheese/"",""url"":""http://www.gnome.org/projects/cheese/"",""visibleUrl"":""www.gnome.org"",""cacheUrl"":""http://www.google.com/search?q\u003dcache:jvfWnVcSFeQJ:www.gnome.org"",""title"":""\u003cb\u003eCheese\u003c/b\u003e"",""titleNoFormatting"":""Cheese"",""content"":""\u003cb\u003eCheese\u003c/b\u003e uses your webcam to take photos and videos, applies fancy special effects   and lets you share the fun with others. It was written as part of Google\u0026#39;s \u003cb\u003e...\u003c/b\u003e""}],""cursor"":{""pages"":[{""start"":""0"",""label"":1},{""start"":""4"",""label"":2},{""start"":""8"",""label"":3},{""start"":""12"",""label"":4},{""start"":""16"",""label"":5},{""start"":""20"",""label"":6},{""start"":""24"",""label"":7},{""start"":""28"",""label"":8}],""estimatedResultCount"":""14400000"",""currentPageIndex"":0,""moreResultsUrl"":""http://www.google.com/search?oe\u003dutf8\u0026ie\u003dutf8\u0026source\u003duds\u0026start\u003d0\u0026hl\u003den-GB\u0026q\u003dcheese""}}, ""responseDetails"": null, ""responseStatus"": 200}";
            g1 = JSONHelper.Deserialise(json);

            foreach (Results x in g1.responseData.results)
            {
                // Anything you want to get
                Console.WriteLine(x.content);

            }
        }
    }

    public class JSONHelper
    {

        public static T Deserialise(string json)
        {
            using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(json)))
            {
                var serialiser = new DataContractJsonSerializer(typeof(T));
                return (T)serialiser.ReadObject(ms);
            }
        }
    }
    [DataContract]
    public class GoogleSearchResults
    {
        [DataMember]
        public ResponseData responseData { get; set; }
    }

    [DataContract]
    public class ResponseData
    {
        [DataMember]
        public IEnumerable results { get; set; }
    }

    [DataContract]
    public class Results
    {
        [DataMember]
        public string unescapedUrl { get; set; }

        [DataMember]
        public string url { get; set; }

        [DataMember]
        public string visibleUrl { get; set; }

        [DataMember]
        public string cacheUrl { get; set; }

        [DataMember]
        public string title { get; set; }

        [DataMember]
        public string titleNoFormatting { get; set; }

        [DataMember]
        public string content { get; set; }
    }
}

Referências:

http://www.json.org/

http://www.codeproject.com/KB/aspnet/G_Search_REST_API_Dot_Net.aspx

http://stackoverflow.com/questions/1212344/parse-json-in-c-sharp

Ferramentas:

JSON Viewer

http://sourceforge.net/projects/nppjsonviewer/

Online JSON Viewer

http://jsonviewer.stack.hu/

JSON Validator

http://jsonlint.com/

Restrições no ISAPI CGI

2012-01-12T19:05:00.000-02:00

O erro

No IIS 7, você pode ter o erro HTTP 404.2 abaixo:

Se você estiver tendo o erro em português:

A página que você está solicitando não pode ser servida devido às configurações da lista de Restrições ISAPI e CGI no servidor Web.

Ou em inglês:

The page you requested could not be displayed because of the settings for the list of ISAPI and CGI restrictions on web server.

A solução

Você deve permitir a execução do .net framework no IIS, abra o Gerenciador do Serviços de Informações da Internet(IIS):

Na raiz, configure as Restrições ISAPI e CGI:

Permita a execução do asp.net

Feito isso, basta tentar acessar sua aplicação/página novamente.

Fonte: http://social.msdn.microsoft.com/Forums/pt/aspnetpt/thread/5ceb2b35-73f6-47a4-9292-4ce2b3f8c83f

Extensão do FireFox para depurar o ASP.NET Ajax - FireAtlas

2009-05-21T10:20:00.003-03:00

O Firebug é uma extensão do FireFox excelente para depurar javascript, css etc. Agora foi criado uma extensão para o Firebug para depurar o ASP.NET Ajax que ainda é grátis:

Para mais detalhes consulte este link:

http://fireatlas.chesnaistechnologies.com/

Abrindo um Web Site do IIS no VS2008

2008-09-14T09:36:00.001-03:00

Ao abrir o VS 2008 pode aparecer o seguinte erro:

“To Access local IIS Web sites, you must install the following IIS components:

IIS 6 Metabase and IIS 5 Configuration Compatibility Windows Authentication”

Instalando Recurso do Windows

Para fazer este acerto, é necessário abrir Iniciar / Painel de Controle / Programas e Recursos:

Feito isso, selecionar : Ativar ou desativar recursos do Windows:

E marcar a opção Compatibilidade com Gerenciamento do IIS 6:

Será necessário reiniciar a máquina, pois o Windows Vista não solicita este reinicio.

Executando o Visual Studio 2008 como administrador

Além disso é necessário executar o Visual Studio 2008 como Administrador:

Permissão no diretório da aplicação

Será necessário dar permissão no diretório da aplicação ao usuário definido no Application Pool da Aplicação no IIS, no meu caso:

Referências:

http://weblogs.asp.net/scottgu/archive/2006/09/19/Tip_2F00_Trick_3A00_-Using-IIS7-on-Vista-with-VS-2005.aspx
http://learn.iis.net/page.aspx/131/compatibility-and-feature-requirements-for-windows-vista/
http://www.marcosdellantonio.net/2008/08/10/visual-studio-2008-e-iis-70/
http://www.devmedia.com.br/articles/viewcomp.asp?comp=3882
http://learn.iis.net/page.aspx/125/metabase-compatibility-with-iis-7/

Monitorando aplicações WEB

2008-09-02T21:17:00.001-03:00

Utilizar os Performances Counters para monitorar a aplicação WEB é interessante. Com ele podemos identificar se há algum gargalo ou ver como anda o desempenho de nossas aplicações, segue dois links interessantes:

http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/4427ad2b-c33b-4b5f-b18a-16568349149a.mspx?mfr=true

http://www.microsoft.com/technet/prodtechnol/WindowsServer2003/Library/IIS/852720c8-7589-49c3-a9d1-73fdfc9126f0.mspx?mfr=true

Controle ASP.NET para Google Maps

2008-08-17T16:31:00.003-03:00

O Google possui uma API para desenvolvedores onde fornece várias funcionalidades como o Google Maps. A documentação do Google Maps pode ser vista neste endereço http://code.google.com/apis/maps/documentation/index.html onde temos acesso a informações como como termos de uso e sobre a necessidade de se criar uma chave para cada diretório de site que for usar o Google Maps.

A chave pode ser criada neste endereço e neste temos acesso aos termos para uso do serviço. O Google representa uma instância do mapa como o objeto GMap. Uma vez com esta instância é possível adicionar vários controles como o GMapType, onde é possível definir o tipo de visualização do mapa. É possível utilizar dos controles já existentes ou criar controles próprios, abaixo segue a lista de controles existentes:

GLargeMapControl - grande controle de zoom e rolagem.
GSmallMapControl - pequeno controle de zoom e rolagem.
GSmallZoomControl - pequeno control de zoom(sem rolagem).
GScaleControl - mapa de escala.
GMapTypeControl - botões que permitem usuários trocarem entre diferentes visualizações de mapa(Como mapa e satélite).
GHierarchicalMapTypeControl - botões e menus para localizar vários tipos de selecionadores do mapa.
GOverviewMapControl - uma visão geral do mapa que pode ser expandido ou fechado.

O Google Maps também tem o conceito de overlay, que são objetos no mapa definidos para coordenadas de latitudes e longitudes. Há vários tipos de overlays:

Makers - são pontos no mapa e algumas vezes mostram ícones customizados. Markers são do tipo GMarker e podem usar o tipo GIcon
Polylines - são linhas no mapa, representando uma coleção de pontos. São do tipo GPolyline.
Polygons - são áreas no mapa que mostram áreas arbritrárias. Similar ao Polylines, só que consiste em uma coleção de pontos que são fechados.
Title overlay - o mapa é representando com o title overlay. Podemos modificar este com nosso próprio conjunto de títulos usando o GTitleLayerOverlay ou criando um GMapType.
Info window - é um tipo especial de overlay. Este é adicionado ao mapa automaticamente é só pode haver um objeto do tipo GInfoWindow anexado ao mapa.

Entendendo o funcionamento do Google Maps com o javascript existem implementações de controles de ASP.NET onde foi feito um controle(wrapper) que facilita o uso desta funcionalidade utilizando .net muitas vezes no lugar do javascript.

Um exemplo desta implementação é este:
http://dotnet.sys-con.com/node/171162

Para baixar os fontes do controle basta ir neste endereço:
http://gemsres.com/story/jan06/171162/source.html

Referências:
http://code.google.com/apis/maps/documentation/controls.html
http://code.google.com/apis/maps/documentation/overlays.html
http://weblogs.asp.net/scottgu/archive/2006/01/22/436166.aspx
http://www.codeproject.com/KB/custom-controls/LatLaysFlat-Part1.aspx
http://dotnet.sys-con.com/node/171162

ASP.NET AJAX RoadMap

2008-07-03T12:55:00.002-03:00

Foi liberado um documento que divulga as novas implementações que estão sendo pensadas para o ASP.NET Ajax:

http://www.codeplex.com/aspnet/Release/ProjectReleases.aspx?ReleaseId=14924

Algumas informações relevantes que pude achar neste documento foi:

Nele é citado como eles pretendem organizar as evoluções da biblioteca e a disponibilização de extensões através do CodePlex;

A idéia de criar uma linguagem de script para facilitar bind de dados em cliente, através de javascript e templates;

Com isso deve ser criado um DataSource em cliente, para permitir um "live binding" e atualização de informações em cliente;

Existem diversas outras informações neste documento, onde a equipe de desenvolvimento do estão com idéias. Vale a pena ver todo o documento e acompanhar estas novidades em suas versões futuras CTP através do site:

http://www.codeplex.com/aspnet

Cliente Web

2008-06-29T17:29:00.001-03:00

Até para dar a devida importância nas tecnologias de cliente, criei outro blog para tratar das tecnologias utilizadas nesta camada. A idéia é publicar e evoluir o material que utilizei para lecionar sobre estas tecnologias e ter algo focado, com teorias e práticas com qualidade em um único lugar.

Veja aqui.

Atualizando a página automaticamente.

2008-06-01T14:02:00.009-03:00

As vezes criamos páginas que terão conteúdos dinâmicos e atualizados com frequência, e ainda por cima, gostaríamos que a atualização acontecesse de forma periódica e automática para nossos usuários. Por exemplo poderíamos citar um site com informações sobre cotações, onde as informações são atualizadas a cada 1 minuto.

Para implementar esta idéia temos várias opções, as duas mais básicas são utilizar javascript ou usar o elemento HTML META.

Javascript

Uma opção com javascript é utilizar o window.setTimeOut, para fazer com que passado o tempo definido, o usuário seja direcionado para a própria página.

Exemplo de atualização em 5 segundos:

<html>
<head>
<title>Exemplo de atualização de página
com javascript</title>
<script type="text/JavaScript">

</script>
</head>
<body onload="doLoad();">
Última atualização as

<script type="text/JavaScript">

</script>

</body>
</html>

Elemento Meta

O elemento HTML META permite que seja adicionado ao documento, a página HTML, informações sobre o próprio documento. Várias informações podem ser adicionadas a página desta forma, como autor, informações sobre cache, informações para bots de pequisa e várias outras. No caso, estamos interessado na atualização(Refresh).

Para utilizarmos a atualização(Refresh), devemos adicionar um elemento meta dentro do elemento head, especificar o atributo http-equiv com o valor refresh, além do atributo content, que contêm o tempo de atualização em segundos e a url destino(se não for a mesma).

<meta equiv="refresh" content="[TEMPO EM SEGUNDOS];[URL DESTINO(Opcional)]">

Neste exemplo é feito a atualização da página atual em 5 segundos:

Há também a possibilidade de se utilizar AJAX, para que não seja necessário a atualização de toda a página, mas somente dos dados que são dinâmicos da página.

Referências:
http://developer.mozilla.org/pt/docs/Utilizando_meta_tags
http://www.w3schools.com/tags/tag_meta.asp
http://msdn.microsoft.com/en-us/library/ms533689(VS.85).aspx
http://grizzlyweb.com/webmaster/javascripts/refresh.asp

Utilizando cookies

2008-05-22T21:55:00.003-03:00

Um cookie é formado por dados em forma de texto que acompanham as requisições e respostas entre navegadores e servidores web. O cookie contêm informações que a aplicação Web pode ler sempre que o usuário visita o site. Desta forma podemos armazenar, por exemplo preferências do usuário através do cookie.

Quando um usuário requisita uma página de um site, o site pode retornar além da página, cookies que são armazenados localmente. Mais tarde, se o usuário requisita uma página do mesmo site novamente, o navegador irá enviar os cookies daquele site juntamente com a requisição.

Os cookies são associados a sites e não a páginas e usuários. Então a medida que os usuários navegam podem ser armazenados cookies de sites que diferentes uns dos outros.

Limitações de cookies

A maioria dos navegadores suportam cookies de até 4096 bytes. Por este pequeno limite, cookies são usados para armazenar pequenas quantidades de dados.

Pode haver também limitações de quantidade de cookies que um site pode armazenar, sendo que a maioria dos navegadores impõem um limite de 20 cookies por site. Alguns navegadores limitam a 300 cookies armazenados na máquina

Outra limitação é que o cliente pode desabilitar cookies

Escrevendo cookies

O ASP.NET escreve cookies na resposta de uma requisição, o navegador que é responsável pela persistência dos dados no cliente. Quando criado um cookie, deve ser especificado um nome e valor. Cada cookie deve ter um nome único, para que possa ser recuperado posteriormente. É possível informar uma data de expiração do cookie, lembrando que o usuário pode limpar os cookies antes da expiração definida pelo nosso código.

Controlando o escopo do cookie

Os cookies podem ter um escopo limitado para diretórios dentro do domínio, utilizando subdomínios do site.

Determinando se o navegador suporta cookie

Uma forma de descobrir se o navegador suporta cookie é enviar um cookie para o usuário e posteriormente tentar lê-lo.

Prática

Vamos agora montar um exemplo que irá armazenar o usuário e data do último login do usuário no site, quando ele marca uma opção para isto. Para isso, crie um novo Web site e na página default.aspx adicione os seguintes controles e defina suas propriedades como abaixo:

Label
- ID: lbUsuario
- Text : Usuário
TextBox
- ID : txtUsuario
Button
- ID: btnEnviar
- Text: Enviar
Label
- ID: lbUltimoLogin
- Text : vazio

Feito isto a parte visual da página deverá estar parecido com a Imagem 1:

Imagem 1 – Página Default.aspx com os controles configurados

Programa o evento click do botão btnEnviar e o Page Load conforme o Código 1:

public partial class _Default : System.Web.UI.Page
{
private const string cookieID = "informacoesUsuario";

protected void Page_Load(object sender, EventArgs e)
{

if (Request.Cookies[cookieID] != null)
{
HttpCookie cookieInformacoesUsuario = Request.Cookies[cookieID];
txtUsuario.Text = cookieInformacoesUsuario["usuario"];
AdicionaInfoUltimaVisita(cookieInformacoesUsuario);
}

}

private void AdicionaInfoUltimaVisita(HttpCookie cookieInformacoesUsuario)
{

if (Request.Cookies[cookieID] != null)
{
lbUltimoLogin.Text = string.Format("Sua última visita foi em : {0}", cookieInformacoesUsuario.Values["ultimaVisita"]);
}

}

protected void btnEnviar_Click(object sender, EventArgs e)
{

HttpCookie cookieInformacoesUsuario = new HttpCookie(cookieID);
cookieInformacoesUsuario.Values["usuario"] = txtUsuario.Text;
cookieInformacoesUsuario.Values["ultimaVisita"] = DateTime.Now.ToString();
cookieInformacoesUsuario.Expires = DateTime.Now.AddDays(10);
Response.Cookies.Add(cookieInformacoesUsuario);

AdicionaInfoUltimaVisita(cookieInformacoesUsuario);

}

Código 1 – Programando o click do BtnEnviar e o PageLoad

Execute o site, digite o usuário e clique em enviar. Feche o navegador, abra outro navegador e visite o mesmo endereço e veja o cookie em ação.

Referências
http://msdn.microsoft.com/en-us/library/ms178194.aspx

Gerenciamento de estado do ASP.NET

2008-05-22T17:37:00.002-03:00

Sabemos que o protocolo HTTP é um protocolo sem estado(Stateless), ou seja, cada requisição feita ao servidor é vista como uma transação independente que não tem relação com requisições anteriores. Então, as aplicações web, que utilizam o protocolo HTTP, não poderiam fornecer conteúdos específicos para um usuário? Depois de entrar num site com usuário e senha, uma segunda requisição não poderia mostrar informações específicas de um usuário? Por isso é necessário utilizar de métodos alternativos para manter estado e iremos pode ser feito no ASP.NET.

O estado do ASP.NET poderia ser definido como uma foto de um determinado momento da utilização da aplicação web pelo usuário. Poderia estar incluído nesta foto diversas informações, como qual usuário que está usando, dados digitados em controles e várias outras. Esta foto poderia incluir inclusive dados que o usuário enviou a vários dias. Para possibilitar esta manutenção de estado, existem alguns recursos:

Recursos para manutenção de estado em cliente:

View State(Estado da exibição)
Control State(Estado de controle)
Campos ocultos
Cookies
Query Strings(String de consulta da url)
Armazenamento de sessão no Cliente(Client side storage)

Recursos para manutenção de estado no servidor:

Application State (Estado do Aplicativo)
Session State (Estado da sessão)
Propriedades de Perfil

Abaixo iremos explicar um pouco de cada um destes recursos.

Recursos para manutenção de estado em cliente:

View State(Estado da exibição)

A página e controles usam por padrão o view state para armazenar seus dados, o ViewState é uma tabela hash onde possui uma chave e um valor, que é o valor do estado armazenado para aquela chave. Esta tabela hash é serializada na codificação base 64 e armazenada em cliente num campo oculto(o elemento input com atributo type=”hidden”). É possível que o usuário desabilite o ViewState de controles ou até mesmo armazene valores próprios, mas é importante ressaltar que como estes dados vão para cliente, deve-se tomar o cuidado com o que é armazenado.

Para exemplificar, podemos pensar que um controle pode por exemplo armazenar informação sobre sua visibilidade no view state, e se por ventura deixar de ficar visível, isto poderia ser atualizado no ViewState.

Control State(Estado de controle)

O Control State trabalha da mesma forma que o View State, só que o View State pode ser desabilitado e o Control State, dessa forma o Control State tem as informações de estado do controle indispensáveis para seu correto funcionamento. O ASP.NET utiliza isto para seus controles e podemos também fazê-lo para nossos controles.

Campos ocultos

O campo oculto(o elemento input com atributo type=”hidden”) permite enviar e recuperar informações no HTML como os demais controles de formulário, só que não renderiza nada para o usuário. Mas apesar de de não mostrar nada para os usuários, usuário mal intencionados podem alterar ou recuperar valores destes campos, por isso deve-se tomar cuidado com os dados que são armazenados desta forma.

Cookies

Um cookie são dados que podem ser armazenados como arquivo de texto no sistema de arquivo do cliente ou na memória da sessão do navegador do cliente. Ele contêm informações específicas do site, que o servidor envia para o cliente através da resposta da requisição da página.

Os cookies podem ser usados para armazenar informações de um cliente em particular, sessão ou aplicação. Os cookies podem ser armazenados no dispositivo cliente, e o navegador envia estes para o servidor juntamente com as informações de requisição. Desta forma estas informações ficam disponíveis para serem utilizadas no servidor.

Como os dados do cookie ficam disponíveis no cliente, usuário mal intencionados podem ter visualizar ou até mesmo modificar estas informações.

Query Strings(String de consulta da url)

A url para requisição de um recurso do servidor pode conter informações extras, como é o caso da Query String. A QueryString inicia após um ponto de interrogação(?) e é formada por um conjunto de pares chave/valor, onde cada par é separado pelo "&". Vejamos um exemplo:

http://www.google.com.br/search?q=aplicacoesweb.blogspot.com

Neste exemplo acima, que funciona se utilizado no navegador, é passado para o mecanismo de busca a querystring q=aplicacoesweb.blogspot.com. Esta querystring contêm um único par que é a chave "q" e o valor "aplicacoesweb.blogspot.com".

Apesar de ser simples a forma de passar informações por Query String, mas alguns navegadores impõe limitações da quantidade de caracteres na URL.

As informações de querystring também podem ser utilizadas e alteradas por usuários mal intencionados.

Armazenamento de sessão no Cliente(Client side storage)

Esta é uma novidade do HTML 5, que alguns navegadores já implementam, o client side storage. Sua idéia é muito parecida com o cookie, mas este vem como solução para dois problemas na utilização de Cookie:

Ter dados disponíveis de forma única para janelas diferentes

Hoje é muito o comportamento de navegadores com várias guias, caso do Firefox 2 e Internet Explorer 7. Se logarmos em um site e abrirmos outra guia, esta outra guia possui a mesma sessão da primeira, pois ambos estão no mesmo processo, na mesma instância do navegador. Já se abrirmos outro navegador, outro processo, estes não compartilham a sessão. O cookie não manipula bem estes casos

Armazenar uma grande quantidade de dados no cliente

Os cookies são sempre enviados para o servidor a cada requisição, então é inviável armazenar uma grande quantidade de dados no cliente.

Atualmente o HTML 5 tem o seu rascunho de implementação, de acordo com o existente da data de 22 de maio de 2008 haverão dois novos atributos DOM, o sessionStorage e o localStorage para resolver esta demanda.

Recursos para manutenção de estado no servidor:

Application State (Estado do Aplicativo)

O ASP.NET permite que informações da aplicação Web sejam salvas no Application State, que é uma instância da classe HttpApplicationState. Estas informações são únicas para todos usuário de uma aplicação Web em específico, mas não é compartilhada entre aplicações Webs. Estas informações são salvas numa tabela de chave/valor.

Session State (Estado da sessão)

o ASP.NET permite que seja armazenado valores de uma sessão usando o Session State, que é uma instância da classe HttpSessionState. Session state é similar ao Application state, armazenando os valores também numa tabela de chave/valor, mas neste caso as informações são únicas para cada sessão do navegador.

Se um usuário sai da aplicação, por exemplo fechando um navegador, e posteriormente retorna ao site, não terá a mesma sessão e não estará disponível no Session State informações da sessão anterior.

O Session State pode ser configurado para armazenar as informações da sessão em banco de dados e de várias outras formas. Por padrão as informações de sessão são armazenadas por um tempo, se o usuário ficar pelo tempo determinado sem fazer requisições ao servidor, será considerado inativo e os dados de sua sessão serão limpos. Este tempo de expiração padrão é 20 minutos.

Propriedades de Perfil

O ASP.NET disponibiliza uma funcionalidade chamada propriedade do perfil(Profile Properties), que permite o armazenamento de dados específicos do usuário. Este é similar a sessão, mas os dados não são perdidos quando a sessão expira.

O perfil ASP.NET permite uma fácil manutenção das informações do usuário, utilizando provedores de perfil(Profile providers). Esta arquitetura de provedores permite uma fácil utilização de provedores existentes, como é o caso do SqlProfileProvider, ou a criação de provedores próprios. Utilizando de provedores persistentes como é o caso do SqlProfileProvider, os dados estarão disponíveis para o usuários numa arquitetura de WebFarm ou mesmo que o IIS reinicie.

Referências:
http://msdn.microsoft.com/pt-br/library/75x4ha6s.aspx
http://msdn.microsoft.com/pt-br/library/bb386448.aspx
http://aplicacoesweb.blogspot.com/2008/04/html-5-como-est-indo.html
http://www.whatwg.org/specs/web-apps/current-work/#structured
http://technet2.microsoft.com/windowsserver/en/library/51aa77d2-4485-4cb9-a75f-9186dc5d775f1033.mspx?mfr=true
http://msdn.microsoft.com/pt-br/library/2y3fs9xs.aspx
http://msdn.microsoft.com/en-us/library/ewfkf772.aspx
http://en.wikipedia.org/wiki/Program_state
http://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol

SQL Server Database no App_data

2008-05-22T17:14:00.002-03:00

Se rodarmos nossas aplicações ASP.NET e estivermos usando SQL Server Database no diretório APP_DATA podemos nos deparar com o seguinte erro se nosso SQL Server não estiver configurado para permitir esta utilização:

Generating user instances in SQL Server is disabled. Use sp_configure 'user instances enabled' to generate user instances.

Para permitir que o Sql Express crie instâncias do usuário, é necessário uma executar a query no Sql Express, abra então o Sql Server Management Studio Express.

Abra o SQL Server Management Studio Express, na pasta Microsoft SQL Server 2005, conforme imagem 1:

Imagem 1 - Abrindo o SQL Server Management Studio Express.jpg

Conecte-se ao servidor local, conforme Imagem 2:

Imagem 2 - Conectando-se no servidor local

Abra a janela para execução da consulta SQL, conforme Imagem 3:

Imagem 3 - Abrindo a janela para execução da consulta SQL

Informe a consulta sql abaixo e mande executar(atalho F5):

sp_configure 'user instances enabled', 1; RECONFIGURE

Feito isto já será possível utilizar bancos de dados SQL SERVER no diretório APP_DATA.

Expressões Regulares no C#

2008-05-14T22:03:00.003-03:00

O C# e várias outras linguagens utilizam de Regular Expression para localização e substituição de strings. Como recentemente postei sobre Validators, há também o RegularExpressionValidator. Só que Regular Expression também não é uma coisa muito fácil e natural, pelo menos para mim, então muitas vezes gosto de utilizar programas para me ajudar a montar as minhas expressões.

Existe este programa escrito em C#, Regular Expression Builder, distribuído na licença GPL:
http://sourceforge.net/projects/regexbuilder/

Achei este programa escrito em Java, Regular Expression Editor distribuído na licença GPL:

http://sourceforge.net/project/platformdownload.php?group_id=219185

Para executá-lo é necessário ter no mínimo o Java Virtual Machine 1.6 para Windows. Baixe neste endereço:

http://java.sun.com/javase/downloads/index.jsp

Outras fontes para estudo:
http://msdn.microsoft.com/en-us/library/ms998267.aspx
http://www.regular-expressions.info/

Usando os controles de validação

2008-05-11T17:47:00.000-03:00

Neste exemplo vamos criar um formulário de compra de títulos, onde será informado para o usuário o valor de um título e poderá ser comprado títulos informando quantidade ou valor. O site fará o cálculo da quantidade ou valor total de acordo com o botão selecionado. O resultado final será conforme Imagem 1.

Imagem 1 - Execução do exemplo

Crie um novo site. Abra a página Default.aspx e adicione um controle label e defina as propriedades da seguinte forma:

ID : lblDescricaoValor
Text: Valor de cada título:

Adicione outro Label e defina as propriedades da seguinte forma:

ID: lblValor

Adicione um controle ValidationSummary e definas as propriedades:

ID: vsQuantidade
ValidationGroup: Quantidade

Adicione mais um controle Label e defina as propriedades:

ID: lblQuantidade
Text: Quantidade:

Adicione um controle do tipo TextBox e defina as propriedades:

ID: txtQuantidadeDesejada

Adicione um controle RequiredFieldValidator e defina as propriedades:

ID: rfvQuantidade
ControlToValidate: txtQuantidadeDesejada

Display: Dynamic

ErrorMessage: Informe a Quantidade
Text: *
ValidationGroup: Quantidade

Adicione um controle CompareValidator, para garantir que um número inteiro seja digitado e defina as propriedades:

ID: cvQuantidade

ControlToValidate: txtQuantidadeDesejada

Display: Dynamic
ErrorMessage: Informe um número inteiro
Operator: GreaterThan

Text: *
Type: Integer
ValidationGroup: Quantidade
ValueToCompare: 0

Adicione um botão e defina as propriedades:

ID: btnCalcularValor
Text: Calcular Valor
ValidationGroup: Quantidade

Nossa página que contêm controles que serão usados no cálculo do valor por quantidade deve parecer com a Imagem 2 :

Imagem 2 - Controles para Calcular Valor

Adicione um controle ValidationSummary e definas as propriedades:

ID: vsValor
ValidationGroup: Valor

Adicione um controle do tipo Label e defina as propriedades:

ID: lblPorValor
Text: Valor:

Adicione um controle do tipo TextBox e defina as propriedades:

ID: txtValorDesejado

Adicione um controle CompareValidator, para garantir que um número inteiro seja digitado e defina as propriedades:

ID: cvValor

ControlToValidate: txtValorDesejado

Display: Dynamic
ErrorMessage: Informe um número inteiro
Operator: GreaterThan

Text: *
Type: Currency

ValidationGroup: Valor
ValueToCompare: 0

Adicione um controle RequiredFieldValidator e defina as propriedades:

ID: rfvValor
ErrorMessage: Informe o Valor
Text: *
ControlToValidate: txtValorDesejado
ValidationGroup: Quantidade

Adicione um botão e defina as propriedades:

ID: btnCalcularQuantidade
Text: Calcular Quantidade
ValidationGroup: Valor

Nossa página que agora também contêm controles que serão usados no cálculo da quantidade por valor deve parecer com a Imagem 3 :

Imagem 3 - Controles para Calcular Quantidade

Adicionamos agora os controles que informam o total da compra. Adicionaremos um Panel e definimos as seguintes propriedades:

ID: pnCompra
GroupingText: Valores de compra
Visible: False

Adicionamos um controle Label dentro do Panel pnCompra e definimos as propriedades:

ID: lblQuantidadeCompra
Text:Quantidade:

Adicionamos um controle TextBox dentro do Panel pnCompra e definimos as propriedades:

ID: txtQuantidadeCompra

Adicionamos um controle Label dentro do Panel pnCompra e definimos as propriedades:

ID: lblValorCompra
Text: Valor da Compra:

Adicionamos um controle TextBox dentro do Panel pnCompra e as propriedades deverão estar definidas como:

ID: txtValorCompra
ReadOnly: True

Adicionamos um controle Button dentro do Panel pnCompra e definimos as propriedades:

ID: btnComprar
Text: Comprar

Nossa página deverá ficar como a Imagem 4:

Imagem 4 - Todos os controles

Vamos agora adicionar os códigos nos eventos apropriados, primeiro vamos programar o a exibição do valor do título. Adicionaremos uma CONST com o valor do título e atribuímos estes no lblValor, conforme código 1:

public const decimal ValotTitulo = 1000;

protected void Page_Load(object sender, EventArgs e)
{
lblValor.Text = ValotTitulo.ToString();
}

Código 1 – Definindo o valor do título

Programaremos o click do btnCalcularValor conforme código 2:

protected void btnCalcularValor_Click(object sender, EventArgs e)
{
decimal valorCompra = ValotTitulo * int.Parse(txtQuantidadeDesejada.Text);
txtQuantidadeCompra.Text = txtQuantidadeDesejada.Text;
txtValorCompra.Text = valorCompra.ToString();

pnCompra.Visible = true;
}

Código 2 – Calculando o Valor

Programaremos o click do btnCalcularQuantidade conforme código 3:

protected void btnCalcularQuantidade_Click(object sender, EventArgs e)
{
decimal valorDesejadoCompra = decimal.Parse(txtValorDesejado.Text);
decimal valorCompra = valorDesejadoCompra - (valorDesejadoCompra % ValotTitulo);
txtValorCompra.Text = valorCompra.ToString();

int quantidade = Convert.ToInt32(valorCompra / ValotTitulo);
txtQuantidadeCompra.Text = quantidade.ToString();
pnCompra.Visible = true;
}

Código 3 – Calculando a Quantidade

Execute a aplicação e repare que as validações acontecem tanto em cliente(Javascript se o navegador suportar), quanto em servidor.

Validações no ASP.NET

2008-05-10T21:48:00.003-03:00

É possível adicionar validações de entrada de dados em nossas páginas ASP.NET usando os controles de validação. Os controles de validação permitem validações flexíveis e customizáveis(inclusive com Regular Expression), e também de necessidades comuns a várias aplicações. Também é possível trabalhar com um sumário de erros e/ou informar por controle que não foi válido.

Os controles de validação podem ser usados com os controles ASP.NET sejam controles Html ou Web.

Os controles de validação são:

Controle	Descrição
RequiredFieldValidator	Valida que o usuário digitou ou selecionou alguma inforação no controle
CompareValidator	Compara se os dados de dois controles são as mesmas.
RangeValidator	Verifica se o dado do controle está dentro do limite inferior e superior definido.
RegularExpressionValidator	Verifica se o dado do controle está de acordo com a expressão regular definida
CustomValidator	Permite a construção de uma validação customizada do usuário utilizando uma lógica do servidor(usando C# por exemplo) e uma lógica de cliente(javascript)

Fazendo a validação

É possível utilizar também grupos de validação, desta forma é possível associar um conjunto de controles a um tipo de validação em especial. Por exemplo é possível fazer em um formulário que o botão OK faça a validação de um conjunto de controles, já o botão Recuperar Senha obrigaria o preenchimento somente do e-mail.

Há disponível na página o método GetValidators que retorna os validadores do grupo de validação definido.

Existe também o controle ValidationSummary que mostra a lista de erros gerados pelos validadores.

Quando usa-se validadores é importante verificar se o estado dos controles que usado por determinada ação está válido. Para isso há disponível:

Os controles de validação tem a propriedade IsValid que informa se o controle é válido
A página tem o método Validate, que pode receber o grupo de validação que deseja-se verificar
A página tem a propriedade IsValid, que informa se a validação aconteceu com sucesso
A página tem o método GetValidators, que pode receber o grupo de validação e retorna os controles de validação.

O momento que ocorre a validação

A validação acontece tanto em cliente quanto em servidor. Em servidor a validação acontece após a inicialização da página(depois de ler o viewstate e dados de postback) e antes que os eventos de alteração e click sejam disparados.

A validação em cliente acontece se o navegador suportar ECMAScript(Javascript). Isto melhora a interatividade, já que as validações assim que o usuário muda o foco de um controle que teve seu valor alterado.

A validação de servidor acontece mesmo que a validação em cliente esteja habilitada, já que usuários mal intencionados poderiam burlar a validação no cliente.

Mostrando as mensagens de erro

Por padrão os controles de validação não estão visíveis ao renderizar a página, e ao não atender uma validação as mensagens de erro são exibidas.

Cada controle de validação pode definir as mensagens de erro através das propriedades:

ErrorMessage : Define a mensagem de erro que exibida no ValidationSummary ou no próprio controle de validação caso a propriedade Text não esteja definida
Text : Define a mensagem de erro que é exibida no controle de validação

Os controles de validação ainda tem a propriedade Display que podem ter os valores:

None: a mensagem de erro não é mostrada no controle
Static: o espaço para a mensagem de erro é reservada no controle de validação
Dynamic: o espaço para a mensagem de erro é utilizado se houver algum erro

Há ainda o controle ValidationSummary que mostra todos os erros da página como sumário. É possível definir a propriedade DisplayMode:

List: mostra os erros em lista, onde cada mensagem de erro é uma nova linha
BulletList: mostra os erros como uma lista de marcadadores
SingleParagraph: as mensagens de erros são mostradas num único parágrafo

Há ainda as propriedades ShowMessageBox que define se as mensagens de erro serão mostradas através de uma caixa de mensagem para o usuário e a propriedade ShowSummary que define se as mensagens de erro serão mostradas como sumário.

Referências:
http://msdn.microsoft.com/en-us/library/7kh55542.aspx
http://msdn.microsoft.com/en-us/library/bwd43d0x.aspx
http://msdn.microsoft.com/en-us/library/ms178313.aspx
http://msdn.microsoft.com/en-us/library/hxet6xwx.aspx
http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.validationsummary.aspx
http://quickstarts.asp.net/QuickStartv20/aspnet/doc/validation/default.aspx

Ferramentas interessantes

2008-05-08T22:01:00.000-03:00

Fazer a diferença de arquivos:
O Winmerge é muito interessante, mostrando a diferença das linhas de dois arquivos e também das colunas, quem trabalha com o source safe e não tem a dificuldade de achar qual o caracter que foi alterado no Diff de uma linha de um arquivo? Com o Winmerge fica mais fácil e ele é Free:
http://winmerge.org/

Visualizar o arquivo, editar fontes:
O notepad++ é um editor de arquivos leve que tem uma visualização diferente para cada tipo de arquivo. Também tem várias funcionalidades como fazer outline de arquivos html, xml.
http://sourceforge.net/projects/notepad-plus/

Ligação entre GridView e FormView

2008-05-07T18:28:00.001-03:00

Vamos neste post fazer a ligação do GridView e um FormView. O GridView mostra vários registros e o FormView mostra um registro em detalhe. Neste post criamos um site e mostramos registros através do GridView e neste post adicionamos a visualização de um único registro através do FormView.

Para isto visualize a página GridView.aspx, vá nas tarefas do controle GridView e clique em Add New Column, conforme Imagem 1:

Imagem 1 - Tarefas do GridView

Selecione o tipo HyperLinkField para a nova coluna, defina o texto Visualizar e para a URL defina conforme Imagem 2:

Imagem 2 - Configurando o HyperLink

Depois de clicar em Ok. Defina a página GridView.aspx como a página inicial da aplicação. Execute o site e clique nos links da coluna adicionada para visualizar o registro.

Mostrando dados com o FormView e Orientação a Objetos

2008-05-06T23:01:00.003-03:00

Vamos abrir o projeto já existente feito através deste post. Após aberto, vamos adicionar um novo método na classe FonteDadosFornecedor para recuperar os dados de um fornecedor passando o código. Então edite o FonteDadosFornecedor.cs e adicione o método conforme Código 1.

public Fornecedor GetFornecedor(int codigo)
{
Fornecedor result = null;
List<Fornecedor> fornecedores = this.RetornaFornecedores();
for (int i = 0; i < fornecedores.Count;i++)
{
if (fornecedores[i].Codigo.Equals(codigo))
{
result = fornecedores[i];
break;
}
}

return result;
}

Código 1 – Método para recuperar os dados de um fornecedor

Adicione uma nova página e renomeie-a para Visualizar.aspx. A solução deverá ter ficado conforme Imagem 1:

Imagem 1 - Solution Explorer

Edite o Visualizar.aspx e adicione um controle FormView, exiba as tarefas do controle e no DropDownList Choose a Data Source selecione a opção “”, conforme imagem 2:

Imagem 2 - Tarefas do FormView

Selecione o ObjectDataSource e defina o nome odsFornecedor e clique em Next, conforme Imagem 3:

Imagem 3 - Definindo o tipo de Fonte de Dados

Selecione o objeto de negócio, no nosso caso o FonteDadosFornecedor e clique em Next, conforme Imagem 4:

Imagem 4 - Definindo o Objeto de negócio

Selecione o método de seleção para a página, será o método recém criado chamado GetFornecedor e clique em Next, conforme Imagem 5:

Imagem 5 - Definindo o Método Select

Vamos receber o parâmetro que define qual o Fornecedor a ser exibido através da querystring, CodFornecedor, configuramos isto no próximo passo e clicamos em Finish conforme imagem 6:

Imagem 6 - Configurando Parâmetro de Seleção

Feito isso, defina a página Visualizar.aspx como a página inicial da aplicação, conforme Imagem 7:

Imagem 7 - Definindo a Página inicial

Edite o modelo de visualização, conforme Imagem 8:

Imagem 8 - Editando o modelo ItemTemplate

Vamos excluir o label que mostra o Site e adicionaremos um hyperlink, feito isso, editaremos os DataBindings conforme Imagem 9:

Imagem 9 - Editando DataBindings do HyperLink

Configure o DataBinding da propriedade NavigateUrl conforme Imagem 10:

Imagem 10 - Binding da propriedade NavigateUrl

Configure o DataBinding da propriedade Text conforme Imagem 11:

Imagem 11 - Binding da propriedade Text

Defina a propriedade Target para o link ser aberto em uma nova janela, conforme Imagem 12:

Imagem 12 - Configuração da propriedade Target

Execute o site e veja o resultado gerado. É possível também adicionar a querystring para visualizar os demais fornecedores, na Url do site adicione o seguinte conteúdo para ver o Fornecedor de Código 1:“?CodFornecedor=1”.

Referências:
http://msdn.microsoft.com/en-us/library/aa581783.aspx

FormView - Visão Geral

2008-05-05T19:51:00.000-03:00

O FormView permite a exibição de um único registro de uma fonte de dados, sendo possível editar, excluir e inserir registros. O problema que ele vem a resolver é o mesmo que o DetailsView, a diferença é que o FormView permite criar modelos(templates) para definir como os controles ficarão.

O FormView suporta as seguintes funcionalidades:

Fazer bind com controles DataSource(SqlDataSource, XmlDataSource, LinqDataSource etc).
Suporte a inserção
Suporte a atualização e exclusão
Paginação
Acesso ao modelo de objetos FormView para definir propriedade, manipular eventos e outros
Customização da aparência através de modelos de usuários, temas e estilos.

Modelos(Templates)

Para que o FormView mostre conteúdo é necessário criar templates para as diferentes partes do controle. A maioria dos templates são opcionais, porém é necessário criar um template para o modo que o FormView está. Os templates do FormView são:

Tipo de modelo(Template)	Descrição
EditItemTemplate	Define o modelo para quando o FormView está em edição. Este modelo geralmente tem controles para entrada de dados com os valores atuais do registros.
EmptyDataTemplate	Define o conteúdo para o modelo quando a fonte de dados não tem registro. Este normalmente tem um aviso para o usuário que não existe o registro solicitado.
FooterTemplate	Este modelo define o rodapé do FomView. Nota: como alternativa é possível definir a propriedade FooterText
HeaderTemplate	Este modelo define o cabeçalho do FomView. Nota: como alternativa é possível definir a propriedade HeaderText
ItemTemplate	Este modelo define o comportamento quando o FormView está em visualização sem permitir a edição.
InsertItemTemplate	Este modelo permite a inserção de registros na fonte de dados.
PagerTemplate	Este modelo permite a navegação entre registros do FormView quando a paginação está habilitada(Propriedade AllowPaging definida para true).

Mostrando Dados

Para fazer bind com controles DataSource deve-se definir a propriedade DataSourceID do GridView com o ID do controle DataSource. Este é preferível em relação ao debaixo, pois provê automaticamente ações como ordenação, atualização, exclusão e paginação.

Para fazer bind com controles que implementam a interface System.Collections.IEnumerable, deve-se através de programação definir a propriedade DataSource e chamar o método DataBind.

Operações de Dados

O FormView reconhece alguns comandos para permitir a atualização, exclusão, inserção e paginação. Como o FormView utiliza modelos(templates) não é gerado automaticamente os botões de comando para estas funcionalidades, então fica a cargo do usuário adicionar estes botões com a propriedade CommandName definido conforme lista abaixo:

Botão	CommandName	Descrição
Cancel	Cancel	Retorna o FormView para o DefaultMode definido.
Delete	Delete	Usado nas operações de exclusão do registro corrente, dispara os eventos ItemDeleting e ItemDeleted.
Edit	Edit	Usado para colocar o FormView no modo de edição.
Insert	Insert	Usado para inserir um novo registro na fonte de dados. Dispara os eventos ItemInserting e ItemInserted.
New	New	Usao para colocar o FormView no modo de inserção.
Page	Page	Usado para paginação. Para usar da paginação defina a propriedade CommandArgument do botão para "Next", "Prev", "First", "Last", ou o indice de página que deseja visualizar. Dispara os eventos PageIndexChanging e PageIndexChanged Nota: Este normalmente é utilizado somente no PagerTemplate
Update	Update	Usado para atualizar o registro na fonte de dados. Dispara os eventos ItemUpdating e ItemUpdated.

Customizando interface com o usuário

É possível customizar a aparência do FormView definindo as propriedades de estilo para as diferentes partes do controle:

Propriedades de estilo	Descrição
EditRowStyle	Configurações de estilo para quando o FormView está em modo de edição.
EmptyDataRowStyle	Configurações de estilo para quando o FormView não contêm nenhum dado.
FooterStyle	Configurações de estilo do rodapé do FormView.
HeaderStyle	Configurações de estilo do cabeçalho do FormView.
InsertRowStyle	Configurações de estilo para quando o FormView está em modo de inserção.
PagerStyle	Configurações de estilo da paginação quando está habilitada.
RowStyle	Configurações de estilo para quando o FormView está em modo de visualização(somente leitura).

Referências:
http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.formview.aspx
http://msdn.microsoft.com/en-us/library/aa581783.aspx

Mostrando dados com o GridView e Orientação a Objetos

2008-05-04T12:17:00.005-03:00

Neste post iremos preencher uma GridView com uma fonte de dados que é uma lista de fornecedores. Para isso criaremos um novo site, adicionaremos a pasta ASP.NET App_Code, nesta adicionaremos as classes Fornecedor e a FonteDadosFornecedor, conforme imagem 1

Imagem 1 – Solution Explorer da solução

Escrevemos o código do Fornecedor conforme Código 1, este código é compatível com o ASP.NET 3.5, para ver o código compatível com o ASP.NET 2.0 veja o Código 2:

using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.HtmlControls;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

public class Fornecedor
{
public Fornecedor(int codigo, string nome, string site)
{
this.Codigo = codigo;
this.Nome = nome;
this.Site = site;
}
public int Codigo { get; set; }
public string Nome { get; set; }
public string Site { get; set; }
}

Código 1 – Fornecedor.cs (ASP.NET 3.5)

using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.HtmlControls;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

public class Fornecedor
{

private int _Codigo;
private string _Nome;
private string _Site;

public Fornecedor(int codigo, string nome, string site)
{
this.Codigo = codigo;
this.Nome = nome;
this.Site = site;
}
public int Codigo
{
get { return _Codigo; }
set { _Codigo = value; }
}
public string Nome
{
get { return _Nome;}
set { _Nome = value; }
}
public string Site
{
get { return _Site;}
set { _Site = value;}
}
}

Código 2 - Fornecedor.cs (ASP.NET 2.0)

Escrevemos o código do FonteDadosFonrcedor conforme Código 3:

using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.HtmlControls;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Collections.Generic;

public class FonteDadosFornecedor
{
public List<Fornecedor> RetornaFornecedores()
{
List<Fornecedor> result = new List<Fornecedor>();
result.Add(new Fornecedor(0, "Microsoft", "http://www.microsoft.com"));
result.Add(new Fornecedor(1, "Google", "http://www.google.com"));
result.Add(new Fornecedor(2, "Oracle", "http://www.oracle.com"));
return result;
}
}

Código 3 – FonteDadosFornecedor

Criamos ou renomearemos uma página existente para GridView.aspx. Para garantir que esta página seja a que será executada ao iniciar a aplicação, clique com o botão direito nesta página e vá na opção “Set as Start Page”, conforme Imagem 2.

Imagem 2 – Set as Start Page

Adicione um GridView ao GridView.aspx, e nas tarefas no GridView na parte “Choose Data Source”, selecione a opção “New Data Source” para definirmos O FonteDadosFornecedor como nossa fonte de dados, conforme imagem 3.

Imagem 3 – Tarefas do GridView

No wizard que será aberto selecione o tipo de dados ObjectDataSource e defina o ID como odsFornecedor conforme Imagem 4 e clique em OK.

Imagem 4 - Definindo o ObjectDataSource como fonte de dados

No próximo passo, selecione nosso objeto de negócio o FonteDadosFornecedor, conforme Imagem 5 e clique em Next.

Imagem 5 – Definindo o Objeto de negócio

Selecione o método de dados para o SELECT, conforme Imagem 6 e clique em Finish.

Imagem 6 - Definindo o Método SELECT

O GridView já identifica quais as colunas são mostradas, vamos agora customizar a coluna Site para ser um HiperLink, nas tarefas do GridView, selecione a opção Edit Columns, conforme Imagem 7.

Imagem 7 – Selecionando a opção Edit Columns

Adicione uma nova coluna do tipo HyperLinkField e defina as propriedades com os seguintes valores:

HeaderText: Site
Define o texto do cabeçalho
Target : _blank
Define que o link será aberto em uma nova janela
DataNavigateUrlFields: Site
Define o campo que será usado na montagem da URL
DataNavigateUrlFormatString: {0}
Define a string de URL, onde {Indice} é substituído pelo campo de indice do DataNavigateUrlFields
DataTextField
Campo a ser mostrado no GridView

Depois exclua a coluna Site existente previamente. O Resultado fica conforme Imagem 8.

Imagem 8 - Configurado o HyperLinkField

Execute o site e veja o resultado gerado. Observe o HTML gerado e a abstração que isto nos deu do HTML.

Referências:
http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.gridview.aspx

Indo para o xUnit.net

2008-05-04T11:10:00.000-03:00

Novo em testes unitários? Leia este post.

Para quem já conhece teste unitário e possivelmente conhece alguma framework como o NUnit. Em 23 de abril deste ano saiu a versão xUnit.net 1.0 RTM(Release To Market). Para quem quiser migrar, esta página faz um comparativo dos diferentes atributos e asserções (Attributes, Assertions):
http://www.codeplex.com/xunit/Wiki/View.aspx?title=Comparisons&referringTitle=Home

O Nunit já tem 5 anos de idade e tem seus padrões bem e mal sucedidos, este link explica o porquê de ter sido criado o xUnit.net, outra plataforma para testes unitários:
http://www.codeplex.com/xunit/Wiki/View.aspx?title=WhyDidWeBuildXunit&referringTitle=Home

Post sobre a alteração para xUnit.net do MoQ:
http://www.clariusconsulting.net/blogs/kzu/archive/2008/04/22/MoQnowusesxUnitforitsunittests.aspx

Veja o site do xUnit.net:
http://www.codeplex.com/xunit

Trabalhando com dados - GridView

2008-05-03T10:06:00.003-03:00

Quando trabalhamos com fontes de dados, há disponível pelo ASP.NET alguns controles para nos auxiliar, como o GridView, o DataList, o DetailsView, FormView e o Repeater. O ASP.NET 3.5 ainda trouxe dois novos controles: ListView e o Repeater.

Os controles são basicamente divididos para exibições de vários registros: GridView, DataList, Repeater e ListView. E exibição de um registro, que é possível usando o DetailsView ou o FormView.

Neste momento vamos falar o GridView, que foi introduzido no ASP.NET 2.0 e substitui o antigo DataGrid. O GridView mostra dados de uma fonte de dados de maneira tabular, onde cada linha do GridView representa uma linha da fonte de dado. O GridView ainda possúi:

Ordenação
Atualização e exclusão
Paginação
Seleção de linha
Multiplas chaves
Multiplos campos de dados para hiperlinks
Cutomização de aparencia através de temas(themes) e estilos(styles)

Cada coluna do GridView representa um atributo do registro, no caso do DataTable, um DataColumn. Cada coluna do GridView é uma classe que descende de DataControlField, e as opções são:

Tipo de Coluna	Descrição
BoundField	Mostra o valor de um campo como texto
ButtonField	Mostra um botão de controle
CheckBoxField	Mostra um CheckBox
CommandField	Mostra um botão de comando para editar, inserir ou excluir
HyperLinkField	Mostra um texto como hiperlink
ImageField	Mostra uma imagem
TemplateField	Mostra um conteúdo de acordo com um modelo(Template) do usuário

O GridView ainda tem a propriedade AutoGenerateColumns, que se habilitadade gera automaticamente colunas para o GridView.

Mostrando Dados com o GridView

Podemos fazer bind o GridView com dados através de controles DataSources(SqlDataSource, XMLDataSource, LinqDataSource) ou com qualquer fonte de dados que implemente a interface System.Collections.IEnumerable.

Para fazer bind com controles que implementam a interface System.Collections.IEnumerable, deve-se através de programação definir a propriedade DataSource e chamar o método DataBind.

Customizando Interface com o Usuário

De maneira mais genérica, podemos customizar a aparência do GridView utilizando Thema e skin. O que permite uma padronização de interface da aplicação Web. Mas podemos também customizar definindo propriedades de estilo de diferentes partes do controle:

Propriedade	Descrição
AlternatingRowStyle	Define o estilo para as linhas alternadas no controle GridView. Quando esta propriedade é definida as linhas do GridView alternam estilos entre RowStyle e AlternatingRowStyle.
EditRowStyle	Define o estilo da linha que está sendo editada no GridView.
EmptyDataRowStyle	Define o estilo das linhas em branco mostradas no GridView, quando a fonte de dados não tem nenhum registro.
FooterStyle	Define o estilo para a linha rodapé do GridView.
HeaderStyle	Define o estilo da linha cabeçalho do GridView.
PagerStyle	Define o estilo do paginador do GridView.
RowStyle	Define o estilo das linhas do GridView. Se a propriedade AlternatingRowStyle é definida as linhas do GridView alternam estilos entre RowStyle e AlternatingRowStyle.

É possível também mostrar ou ocultar o cabeçalho e o rodapé do GridView utilizando respectivamente das propriedades ShowHeader e ShowFooter.

Referências:
http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.gridview(VS.80).aspx
http://www.microsoft.com/brasil/msdn/Tecnologias/aspnet/ExplorandoGridView.mspx

Bind do DropDownList com uma lista genérica

2008-05-02T13:23:00.003-03:00

O DropDownList do ASP.NET pode fazer bind com uma lista genérica(System.Collections.Generic.List), desta forma podemos trabalhar orientado a objetos ou da forma já comum utilizando DataTable. Neste exemplo abaixo criaremos uma classe de Pessoa, criaremos uma lista genérica do tipo Pessoa e faremos o bind com o DropDownList.

Crie um novo site e adicione a classe Pessoa no diretório App_Code, conforme imagem abaixo:

Imagem 1 - Estrutura da aplicação

Coloque duas propriedades na classe pessoa, uma do tipo inteiro Codigo e outra string Nome. Como estamos utilizando o ASP.NET 3.5 podemos fazer conforme código 1:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

public class Pessoa
{
public Pessoa(int codigo, string nome)
{
this.Codigo = codigo;
this.Nome = nome;
}

public int Codigo { get; set; }
public string Nome { get; set; }
}
Código 1 - Classe Pessoa(ASP.NET 3.5)

Para quem utiliza o ASP.NET 2.0 deverá escrever conforme Código 2:

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;

public class Pessoa
{
private int codigo;
private string nome;
public Pessoa(int codigo, string nome)
{
this.Codigo = codigo;
this.Nome = nome;
}

public int Codigo
{
get
{
return codigo;
}
set
{
codigo = value;
}
}

public string Nome
{
get
{
return nome;
}
set
{
nome = value;
}
}
}
Código 2 - Classe Pessoa(ASP.NET 2.0)

Na página, adicione um DropDownList no Default.aspx, altere seu nome para ddlPessoa, conforme Imagem 2 :

Imagem 2 - Adicionando o DropDownList ddlPessoa

Visualize o CodeBehind do Default.aspx(Default.aspx.cs) e no evento Page_Load adicione o código conforme código 3, este cria uma lista de pessoas, faz as configurações necessárias no ddlPessoa e chama o método DataBind para adicionar os valores ao DropDownList.

As configurações necessárias no ddlPessoa é definir a fonte de dados que irá montar os itens, isto é feito definindo a propriedade DataSource, configuramos a lista de Pessoa. Também é necessário configurar as propriedades DataValueField e DataTextField, como cada item do nosso DataSource é uma instância de Pessoa, definimos nestes quais as propriedades de Pessoa, neste caso as propriedades Codigo e Nome.

Outra inforamção importante é que estamos usando generics é necessário adicionar o using ao namespace System.Collections.Generic:

using System;
using System.Collections;
using System.Configuration;
using System.Data;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Collections.Generic;

public partial class Default : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
List<Pessoa> listaPessoas = new List<Pessoa>();
listaPessoas.Add(new Pessoa(0, "Mateus"));
listaPessoas.Add(new Pessoa(1, "Maria"));
listaPessoas.Add(new Pessoa(2, "Jose"));

ddlPessoa.DataSource = listaPessoas;
ddlPessoa.DataValueField = "Codigo";
ddlPessoa.DataTextField = "Nome";
ddlPessoa.DataBind();
}
}

Código 3 - Código da página Default.aspx.cs

Salve tudo e execute o site, visualize também o HTML gerado.
Imagem 3 - Resultado no navegador

Referências:
http://msdn.microsoft.com/en-us/library/ms379564(VS.80).aspx
http://digitalcolony.com/2008/01/bind-generic-list-to-aspnet.aspx

Page Class - A página do ASP.NET

2008-04-22T21:47:00.001-03:00

ASP.NET Modelo de codificação da página web

Uma página ASP.NET consiste em duas partes:

Elementos visuais, que inclui marcação específica(server controls ) e html(textos estáticos)
Lógica de programação da página, que contêm eventos e outros códigos

Existem dois modelos para gerenciar os elementos visuais e códigos, ambos funcionam da mesma maneira, mas diferenciam em sua utilização: Single File(Arquivo único) e Code Behind.

Single File (Arquivo único)

Neste modelo tanto o visual quanto o código ficam num arquivo único. Isto facilita a manutenção para páginas simples e serviços como renomear arquivos.

Code Behind(Arquivo de código separado)

Neste modelo a parte de código é separado da parte visual. Isto é bastante interessante, pois passamos a ter um controle separado da parte visual e código, facilitando o trabalho entre desenvolvedores e designers.

Page Class

As requisições aos recursos ASP.NET são repassados pelo IIS pelo executor de ASP.NET. Neste momento estou limitando a citar a requisição de páginas, do ASPX.

Ao requisitar uma página, o executor do ASP.NET combina a página, elementos de servidor, como controles, para manipulação de eventos que escrevemos. Como não temos que compilar as páginas em assemblies, netes casos o ASP.NET compila a página na primeira requisição a página. Caso a página ou algum recurso que a página depende sofra alguma alteração a página é recompilada automaticamente.

O ASP.NET pode compilar as páginas previamente para melhorar o desempenho da aplicação: http://msdn2.microsoft.com/en-us/library/399f057w.aspx

Ciclo de vida da página

A página ASP.NET é executada num ciclo de vida que passa por várias etapas. Estas incluem inicialização, instanciar controles, recuperar e manter estado, executar manipuladores de eventos e renderizar. É importante dominar o ciclo de vida da página para utilizar os eventos apropriados quando necessário.

Estágio	Descrição
Solicitação de página	A solicitação de página ocorre antes que o ciclo de vida da página comece. Quando a página é solicitada por um usuário, ASP.NET determina se a página precisa ser analisada e compilada (portanto, começando a vida de uma página) ou se uma versão em cache da página pode ser enviada em resposta sem executar a página.
Iniciar	Na etapa inicial, as propriedades da página, como Request e Response são definidas. Nesse estágio, a página também determina se o Request é um Postback ou um novo Request e define a IsPostBack Propriedade. Além disso, durante a etapa inicial, a propriedade UICulture da página é definida.
Inicialização da página	Durante a inicialização de página, os controles da página estão disponíveis e é definido a propriedade UniqueID de cada controle. Os temas também são aplicados para a página. Se a solicitação atual for um postback, os dados PostBack ainda não foram carregados e valores da propriedade do controle não foram restaurados com os valores do ViewState.
Carga	Durante o carregamento, se a solicitação atual é um postback, as propriedades de controle serão carregadas com informações recuperadas do ViewState e do ControlState.
Validação	Durante a validação, o método Validate de todos os controles de validação são chamados, este define a propriedade IsValid de cada um dos controles validadores da página.
Tratamento de evento PostBack	Se a solicitação for uma postback, quaisquer manipuladores de eventos são chamados.
Renderização	Antes da renderização, o viewstate é salvo para a página e todos os controles. Durante a fase de renderização, a página chamará o método Render para cada controle, fornecendo um escritor de texto que grava a saída para o Stream de saída da propriedade Response da página.
Descarregar	O descarregar é chamado quando a página tiver sido processada, enviada para o cliente e está pronta para ser descarregada. Neste ponto, as propriedades da página, como Response e Request são descarregados e toda limpeza será executada.

Referências:
http://msdn2.microsoft.com/en-us/library/015103yb.aspx
http://msdn2.microsoft.com/en-us/library/ms178138.aspx
http://msdn2.microsoft.com/pt-br/library/ms178472.aspx
http://msdn2.microsoft.com/pt-br/library/aa479007(en-us).aspx