100loop.com

Transformações do Web.Config Visual Studio 2010

André Castro — Thu, 09 Sep 2010 12:52:54 GMT

Olá filhotes! Hoje só para variar irei mostrar uma nova função do Visual Studio 2010, o Web.Config Transformation. Agora com o Visual Studio 2010 nós podemos ter vários web.configs diferentes para cada publicação. Como assim? Bom… quando você esta no ambiente de desenvolvimento o seu banco é diferente do banco de produção, então quando você publicava o seu projeto você era obrigado á alterar o web.config, não só a string de conexão, mas qualquer outra configuração de segurança, etc… Agora nós podemos “ter” um Web.Config para cada ambiente. Vamos lá:
Já repararam que agora o Web.Config tem a opção de ser expandido (Se estiver usando VB você vai precisar habilitar a opção de “Ver todos os arquivos”).
Por padrão nós temos o Web.Debug e o Web.Release, são os nossos arquivos de transformação. Um arquivo de transformação serve para informar quais atributos iremos alterar/adicionar/remover no nosso Web.Config original, então na verdade nós só temos um Web.Config que é transformado automaticamente para cada ambiente. Mas os arquivos de transformação devem ser arquivos XML válidos! Dentro dos arquivos por padrão há comentários com exemplos de como substituir os nós do Web.Config original, e também terá essa tag:

<?xml version="1.0"> <configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform"> </configuration>

Mas o que é isso? Bom, para fazer as transformações no nosso Web.Config nós precisamos usar os atributos do namespace XML-Document-Transform, então todos os arquivos de transformação devem ter esse namespace registrado. O namespace XML-Document-Transform é composto por dois atributos: Locator e Transform. O Locator é usado para localizar o elemento que você vai modificar e o Transform determina a ação que acontecerá ao elemento ( Excluir, Alterar, Adicionar ). Deixe eu exemplificar isso, vamos dizer que eu tenho essa connection string no meu Web.Config:

Mas quando formos publicar ele para o cliente iremos usar outra string de conexão, já que acessaremos o banco de produção. Para isso nós iremos precisar adicionar essa nova string de conexão no nosso arquivo de transformação (nesse caso, o web.Release ):

Perceberam que adicionei o Locator e o Transform ? Então, agora vamos ver o porquê dos valores: O Transform Replace significa que iremos substituir todo o nó, e o Locator Match(name) mostra que ele ira procurar pelos nós (Dentro de Configuration / ConnectionStrings / Add) cujo parâmetro (nesse caso o name) possui o mesmo valor. Com essa linha nós substituiremos a string de conexão DbPortal do Web.Config pela do Release.
Existem outros Locators e Transforms, vamos ver o que cada um faz:

Locators

Match([args]) – Como dito antes, procura elemento(s) com o mesmo valor do argumento, sendo que você pode passar mais argumentos separando por virgula.

Condition([arg]) - A condição será transformada em uma expressão XPath e será associada ao elemento. Acha todos os nós que “batem” com as condições. No nosso exemplo ele substituirá a connection string TempDB que também possui como providerName System.Data.SqlClient

O XPath real fica sendo: configuration/connectionStrings[@name='TempDB' or @providerName='System.Data.SqlClient']

XPath([XPath expression]) - Ao contrario do Condition você tem que passar toda a expressão XPath. No nosso exemplo ele removerá a connection string ReleaseDB e todas com o Provider igual à System.Data.SqlClient

Como visto no ultimo exemplo, há (vários) outros transforms:

Replace – Substitui a primeira ocorrência do(s) nó(s) encontrados completamente, juntamente com seus filhos.

Remove – Remove a primeira ocorrência do(s) nó(s) encontrados, juntamente com seus filhos.

RemoveAll – Remove todas as ocorrências do(s) nó(s) encontrados, junto com os filhos.

Insert – Insere o nó como ultimo item da configuração.

<globalization culture="jp-JP" uiCulture="jp-JP" requestEncoding="ISO-8859-1" responseEncoding="ISO-8859-1" fileEncoding="ISO-8859-1"  xdt:Transform="Insert" />

InsertAfter(XPath) – Insere o nó logo após o elemento definido pelo XPath. Ex: Vamos inserir uma chave “EmailCopia” no AppSettings logo após o “EmailUsuario”

 <appSettings>     <add key="EmailCopia" value="homologacao@100loop.com.br" xdt:Transform="InsertAfter(/configuration/appSettings/add[@key='EmailUsuario'])"/>   </appSettings>

InsertBefore(XPath) – Insere o nó antes do nó especificado no XPath.

SetAttributes – Substitui os atributos do nó em vez do nó inteiro. Pode se passar mais de um atributo separando-o por virgula.

 <connectionStrings>     <add name="MyDB"       connectionString="Data Source=ReleaseSQLServer;Initial Catalog=MyReleaseDB;Integrated Security=True"         providerName="System.Data.SqlClient"       xdt:Transform="SetAttributes(connectionString)" xdt:Locator="Match(name)"/>   </connectionStrings>

RemoveAttributes – Remove um ou mais atributos de um nó.

<compilation xdt:Transform="RemoveAttributes(debug,batch)" />

Pronto. Basta você colocar cada nó que você deseja substituir no arquivo de transformação usando o Transform e Locator e seu Web.Config estará configurado para cada ambiente. Se você quiser também você pode copiar todo o Web.Config para o arquivo de transformação, fazendo a modificação no que você queira, e adicionando o Transform="Replace" no primeiro nó. Com isso você substitui todo o web.config por outro. Nesse caso não é necessário o Locator, já que substituirá todo web.config.
E claro, mas como o Visual Studio sabe em qual ambiente nós queremos publicar? Basta irmos no combo Solution Configurations na toolbar e alterar o tipo de ambiente em que iremos publicar.

Há a possibilidade também de criar novas configurações, para isso basta ir em configuration manager, e em Active solution configuration selecionar <New...>.

E adicione o nome do seu novo ambiente, se quiser pode copiar as configurações de outro ambiente para esse novo. Depois de criar um novo ambiente, basta clicar com o botão direito sobre o Web.Config e escolher Add Config Transforms.

Será criado um arquivo de transformação para cada configuração nova.

Eu sei que o grande @ivanpaulovich ira falar um pouco sobre esse assunto também na palestra dele no Tech Ed.
Espero que tenham gostado! Ate mais!

Fontes: http://msdn.microsoft.com/en-us/library/dd465326.aspx
http://blogs.msdn.com/b/webdevtools/archive/2009/05/04/web-deployment-web-config-transformation.aspx
Introdução ao XPath: http://www.microsoft.com/brasil/msdn/Tecnologias/visualc/XPath.mspx

Implementando aplicações extensíveis com ASP.NET MVC 2

Ivan Paulovich — Mon, 06 Sep 2010 17:03:47 GMT

A Microsoft liberou hoje as inscrições para a palestra WEB309 - Implementando aplicações extensíveis com ASP.NET MVC 2 no Tech-Ed Brasil 2010.

Nessa palestra você irá descobrir o mundo do desenvolvimento de aplicações extensíveis com ASP.NET MVC.

Partimos do pré-requisito que os pilares do MVC já estão consolidados e fazemos demonstrações que abrangem MVC Areas, Url Routing, implementações de VirtualPathProvider e especialmente ViewEngines.

Voce sairá dessa palestra com o conhecimento prático em como extender sua Web Application através de plugins.

Os conceitos fundamentais dessa palestra me acompanham pelos últimos meses e essa será uma ótima oportunidade de dividir com você o que eu aprendi.

Recomendo também que você assista a palestra WEB201 - ASP.NET MVC para desenvolvedores Web Forms para chegar preparado e as paletra WEB302 - ASP.NET MVC 2: O que há de Novo? para ficar ligado nas novidades.

Entao não perca tempo e ajuste sua agenda.

Asp .Net MVC 3 - Preview 1

Luciano Lima — Mon, 06 Sep 2010 12:49:34 GMT

Fala galera tudo tranks?

Antes de darmos continuidade aos posts sobre WCF, gostaria de apresentar a vocês o mais novo preview do Asp Net MVC 3.

Para que vocês possam acompanhar o post da melhor forma possível, abaixo segue o link para download do primeiro preview, clique aqui.

O Asp .NET MVC 3 será compatível com a sua versão anterior, o Asp .NET MVC 2, contudo, isso não significa que será fácil atualizar os projetos que você está escrevendo com o MVC 2 para o MVC 3 quando eles lançarem a versão final.

As funcionalidades do Asp .Net MVC 3 tem como base as funcionalidades do Asp .Net MVC 1 e 2, ou seja, todo seu conhecimento adquirido em sites e livros não serão perdidos, isso porque, as funcionalidades do Asp .Net MVC 1 e 2 não se tornaram obsoletas.

Ok Luciano, mas a pergunta de todos é: “Posso instalar o Asp .Net MVC 3 junto com o ASP.NET MVC 2?”, a resposta é sim, você pode, inclusive a versão preview, sem que esta impacte projetos existentes da versão do Asp .Net MVC 2 que você esteja trabalhando, eles continuarão a usar o Asp .Net MVC 2 a menos que você modifique os projetos para que estes passem a usar o Asp .Net MVC 3.

Quando você instalar a versão "Preview 1", você terá um novo conjunto de templates de projeto para o Asp.Net MVC 3 que aparecerão na janela de diálogo de Novo Projeto do Visual Studio 2010.

Vamos ver algumas das novas funcionalidades e capacidades do Asp .Net MVC 3. Ressalvo que tudo que fizermos aqui são funcionalidades da versão 3 do Asp Net MVC, isso não quer dizer que novas funcionalidades não possam sair em versões futuras.

View

O Asp.Net MVC 3 "Preview 1" inclui um conjunto de melhorias específicas para a View.

Janela de Diálogo
Foi criada uma nova janela de diálogo "Add->View", que torna mais fácil sua escolha quanto a sintaxe a ser utilizada. Ela permite que você selecione qualquer um dos motores de exibição disponíveis que estejam instalados na sua máquina, o que lhe dá a habilidade de usar qualquer abordagem de modelagem de visão que pareça mais natural para você.

Figura 01 – Nova janela Add View

Nova Engine Razor
Não irei entrar em detalhes sobre a Engine Razor, isso porque daria outro post, então, sugiro que vocês deem uma lida no post do Scott Guthrie sobre o Razor

Controller

Assim como para a View, o Controller também ganhou algumas novidades:

Filtros Globais
O Asp.Net MVC 3 suporta a capacidade de aplicar de forma declarativa lógica "contínua" usando um mecanismo chamado de "filtros". Você pode especificar filtros nos controladores e métodos de ação hoje usando uma sintaxe de atributo conforma a listagem 1.

Listagem 01 – Filtros

[HandleError]
[LoaderOptimization(128)]
public ActionResult Index()
{
    ViewModel.Message = "Aplicação Asp.Net MVC 3";

    return View();
}

Muitas das vezes precisamos aplicar filtros a todos os controladores de uma aplicação, com o Asp .Net MVC 3, foi adicionado um método chamado RegisterGlobalFilters que irá adicionar os filtros à coleção GlobalFilters. Basta fazer a chamada no Application_Start() do seu Global.asax.

Listagem 02 – Filtros Globais

public static void RegisterGlobalFilters( GlobalFilterCollection filters )
{
    filters.Add( new HandleErrorAttribute() );
}

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();

    RegisterGlobalFilters( GlobalFilters.Filters );
    RegisterRoutes( RouteTable.Routes );
}

O Asp .Net MVC 3 é flexível no que diz respeito a filtros, de modo que você pode configurar um filtro global que será aplicado condicionalmente apenas se forem respeitadas determinadas condições. Por exemplo, se a depuração estiver habilitada; se uma requisição usar um verbo http dentre outras. Os filtros também podem ser resolvidos a partir de um Conteiner.

ViewModel Dinâmico
Os Controladores do Asp.Net MVC suportam uma propriedade "ViewData" que permite a você transmitir dados para uma View usando uma coleção (Dictionary) como na listagem 03.

Listagem 03

ViewModel["Message"] = "Aplicação Asp.Net MVC 3";

Já na versão 3 do MVC, foi adotada a propriedade dinâmica, dynamic, ela permite que você use o novo
suporte à linguagem dinâmica tanto do VB quanto do C# para passar itens da ViewData usando uma sintaxe um pouco mais limpa do que aquela utilizada com a API de dicionário atual. Observe a figura 2, a propriedade Message só será conhecida em tempo de execução.

Figura 02 – Dinamismo

ActionResult
As novidades não param por ai! O Action Result também ganhou novas funcionalidades:

HttpNotFoundResult

A nova classe HttpNotFoundResult é usada para indicar que um recurso solicitado pela URL atual não foi encontrado. Ela retorna um código de status HTTP 404 para o cliente que realizou a chamada. Opcionalmente, você pode usar o novo método de ajuda HttpNotFound() no controlador para retornar uma instância desse tipo de resultado de ação, conforme a listagem 4.

Listagem 04

public ActionResult RecuperaProduto(int codProduto)
{
    var prod = new Produto.Find(codProduto);

    if ( prod == null )
        return HttpNotFound();

    return View();
}

Redirecionamentos Permanentes

A classe HttpRedirectResult tem uma nova propriedade "Permanent" do tipo booleano que é usada para indicar se um redirecionamento permanente deve ocorrer. Um redirecionamento permanente usa o código de status HTTP 301. Em conjunto com esta mudança, a classe Controller tem agora três novos métodos para realizar redirecionamentos permanentes: RedirectPermanent(), RedirectToRoutePermanent(), e RedirectToActionPermanent().

Esses métodos retornam uma instância do tipo HttpRedirectResult com a propriedade Permanent definida com true.

HttpStatusCodeResult

A nova classe HttpStatusCodeResult pode ser usada para definir um código de status e descrição de resposta de forma explícita.

Ajax e Javascript
Dando continuidade às novidades, o Asp.Net MVC 3 inclui suporte para JSON, o que permite que os métodos recebam dados codificados no formato JSON podendo assim, vinculá-los como parâmetros dos métodos.

Observe o código da listagem 5, ele define um manipulador de eventos "save" que será chamado quando um botão salvar for clicado no lado cliente. O código dentro do manipulador de eventos irá criar um objeto "produto" no código JavaScript com dois campos, cujos valores são obtidos a partir de elementos de entrada HTML. Em seguida, ele usa o método .ajax() da jQuery para postar (POST) uma requisição baseada em JSON que contém o produto para uma URL /Store/UpdateProduct no servidor.

Listagem 05 – método Ajax

$("#save").click(function () {
    var prod = {
        NomeProduto: $("#ProdName").val(),
        Valor: $("#value").val()
    };

    $.ajax({
        url: "/Store/UpdateProduct",
        type: "Post",
        data: JSON.stringify(prod),
        dataType: "json",
        contentType: "application/json; charset=utf-8",
        sucess: function () { $("message").html("Produto atualizado").fadeIn() },
        error: function () { $("message").html("Erro ao atualizar o Produto").fadeIn() }
    });

    return false;
});

No lado servidor você terá algo como na listagem 6.

Listagem 06 – Atualizar Produto

public ActionResult UpdateProduct(Produto produto)
{
    //Implementar a lógica para atualização de um produto
    return null;
}

Validação do Modelo

No Asp.Net MVC 2, houveram algumas melhorias no que diz respeito à validação, no Asp .Net MVC 3, este trabalho foi estendido e ainda por cima eles adicionaram suporte para vários outros novos recursos de validação e os introduziram no namespace System.ComponentModel.DataAnnotations do .NET 4. São eles:

Suporte aos novos atributos de metadados – DataAnnotations, tais como DisplayAttribute.

Suporta as melhorias feitas na classe ValidationAttribute no .NET 4. A classe ValidationAttribute foi melhorada no .NET 4 para suportar uma sobrecarga nova IsValid que fornece mais informações sobre o contexto de validação corrente, permitindo saber por exemplo qual é o objeto que está sendo validado. Isso permite cenários mais ricos, onde você pode validar o valor atual baseando-se em outra propriedade do modelo.

Suporta à nova interface IValidatableObject introduzida no .NET 4. A interface IValidatableObject permite a execução de validação no nível do modelo, e permite que você forneça mensagens de erro de validação específicas para o estado geral do modelo, ou entre duas propriedades do modelo.

Na listagem 7, podemos ver como utilizar a a interface IValidatableObject nativa no .NET 4 para implementar um método de validação personalizado em uma classe.

Listagem 07 – Implementando IValidatableObject

public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
    if ( string.IsNullOrEmpty( NomeProduto ) )
        return (IEnumerable<ValidationResult>) new ValidationResult("Você deve preencher o campo Nome do Produto");
    return null;
}

Além da interface IValidatableObject, o Asp.Net MVC 3 também apresenta uma nova interface chamada IClientValidatable que permite descobrir em tempo de execução se um validador tem suporte para a validação no lado do cliente. Esta interface foi projetada de modo que possa ser integrada com uma variedade de frameworks de validação.

Dependency Injection

O Asp.Net MVC 3 nos dá um melhor suporte para aplicação de injeção de dependência (DI) e integração com Conteiners de injeção de dependência.

Para a versão "Preview 1", foram adicionados suporte para injeção de dependência nos seguintes locais:

Controladores (registro e injeção de fábricas de controladores, injeção de controladores)

Visões (registro e injeção de motores de visão, injeção de dependências em páginas de visão)

Filtros de Ação (localização e injeção de filtros)

Para futuras versões, poderão ser acrescentados os seguintes suporte para injeção de dependência em:

Model Binders - Vinculadores de Modelo (registro & injeção)

Value Providers - Provedores de Valor (registro & injeção)

Validation Providers - Provedores de Validação (registro & injeção)

Model metadata Providers - Provedores de Metadados de Modelo (registro & injeção)

Ufa, finalmente terminei, acho que vocês não viam a hora né!!

Como podem ver, as melhorias são muitas, isso na versão Preview 1 heim!! Imagina o que vem por ai. Espero poder postar a vocês tudo que for novidades no Asp .Net MVC 3.

É isso ai galera, até o próximo post!

Enjoy!

Aproveite o Community Zone ao máximo

Ivan Paulovich — Mon, 30 Aug 2010 22:46:38 GMT

O guia a seguir irá ajudar os estreantes de Community Zone a aproveitarem o máximo do evento. O que você irá ler a seguir vem de experiência de 3 CZ’s e tem como único objetivo te ajudar a interagir melhor no evento.

O que é o Community Zone?

É um evento organizado pela Microsoft onde ela reúne os principais influenciadores do Brasil com os objetivos:

Colher feedback dos participantes.
Aumentar a integração entre os grupos e pessoas.
Formentar novas iniciativas e (HCLs, Community Launchs, Copa Microsoft de Talentos).
Capacitar os líderes de grupos.

O que a Microsoft espera de você?

Que as informações e projetos iniciados no CZ sejam levados aos grupos de usuários.
Que você realize mais eventos e da forma correta.
Que você faça mais webcasts.
Que você participe ainda mais dos fóruns.
Que você recupere as energias e gere ainda mais informações online.

É a sua primera vez?

Se sim. Vamos contextualizar algumas coisas. Provalvemente as pessoas te conhecem pelo seu “perfil online”. Isso mesmo, as pessoas conhecem muito bem o seu avatar e os conteúdos que você disponibiliza na internet mas dificilmente de reconheceriam na rua pessoalmente.

Logo, você precisa mostrar a sua cara! Não tenha vergonha, não seja “o tímido” do grupo. O evento foi planejado para termos integração, então faça isso ora-bolas.

É um veterano de CZ’s?

Você já foi uma ou mais vezes ao Community Zone e já conhece várias pessoas, conhece o time da Microsoft, tem idéia do que esperar do evento. Logo você é a pessoa perfeita para mostrar aos estreantes como você é um cara legal. Passe um pouco da sua experiência de comunidades pra frente. É esse o verdadeiro espírito de comunidade.

Evite grupinhos, seja aberto a conhecer outras pessoas

Com toda certeza você tem aqueles amigos mais próximos e que você com certeza gostaria de conversar muito e eles estarão lá no CZ.

Mas fique atento a alguns detalhes: provalmente existem dezenas de pessoas com as quais você poderia iniciar um projeto, trocar experiência e se tornar mais um amigo.

Logo, aumente o seu networking no Community Zone trocando idéias com várias pessoas.

Tenha o seu cartão pessoal a mãos

Você irá conhecer outras pessoas com as quais gostaria de manter contato. Então facilite as coisas, tenha a mãos alguns cartãosinhos com seu nome, MSN e twitter. Dessa forma você simplifica a troca de contatos.

Isso é sério, ao final do evento você irá despedir de várias pessoas e irá querer os contatos dela. Evite o desajeitado e demorado momento em que você pede para a pessoa so-le-trar o e-mail.

Converse com o time da Microsoft

O time da Microsoft no Brasil é muito seleto. São profissionais com uma experiência gigatesca com as quais 5min de conversa equivalem a várias horas de palestras e treinamentos.

Além de serem ótimas pessoas, com as quais é bem divertido tomar um coca-cola e conversar sobre os grupos de usuários, tecnologias, carreira e assuntos diversos. Não perca essa oportunidade que o CZ proporciona.

Fale com esses caras

@ivanpaulovich, @andrepaulovich e @alrcastro. Nós trabalhamos juntos aqui em Belo Horizonte e somos pessoas legais ;-)

Divirta-se

O Community Zone é um evento de integração. E certamente a Microsoft irá bolar várias atividades interessantes e também nos dará um tempo livre para aproveitarmos o hotel. Logo, há tempo pra tudo. Tempo para consumir informação e tempo para se divertir com os amigos que você acabou de fazer (ou irá fazer).

Considerações

Todas essas idéias foram tiradas da minha experïência com CZ’s e somente tem o intuito de ajudar a comunidade a interagir. Se você concorda ou discorda de algum ponto fique a vontade nos comentários.

Eu vou ao Tech-Ed Brasil 2010

Ivan Paulovich — Mon, 30 Aug 2010 22:04:08 GMT

Sou o mais novo palestrante do Tech-Ed Brasil 2010. Eu participei da concurso o TechEd Brasil é um Evento de Féras e o meu vídeo foi o escolhido como vencedor.

A idéia do concurso era criar um vídeo de no máximo 2min explicando os motivos que justificariam a comissão do Tech-Ed a me convidarem a ser um dos palestrantes. Você pode conferir o making of aqui mesmo no blog.

Se você não viu a produção final vale a pena a assistir (e quem sabe rir um pouco):

Vejo vocês no Tech-Ed Brasil 2010! (e também no Community Zone)

Atualizações

Recebi algumas perguntinhas sobre o vídeo, e vou tentar esclarescer um pouco mais sobre a composição. Primeiro, eu havia pensado em fazer um vídeo num escritório e me aproveitar de uma lousa onde irião passar algumas imagens (semelhante a videos de previsões do tempo).

Mas depois, conversei com o André Paulovich e ele achou isso bem comum e com poucos diferenciais. E então veio a idéia de gravar um video caminhando por entre alguns objetos e enquanto eu explicava os motivos para ser um palestrante.

Esse modelo também não deu certo. Por que o tempo do video era de 2min, e o caminhar por entre objetos ficava curtissimo e não conseguimos passar essa ideia pra frente. Além de termos problemas com o tremedeira na cãmera. Não estava ficando legal.

Tivemos então a idéia de fazer algo semelhante aos comerciais da Nextel. Vimos que o único jeito de termos um efeito parecido era fazer uma filmagem usando um carro como suporte e falando o texto bem rápido já que o tempo era curto. O resultado disso tudo é o vídeo que vocês viram nesse post.

Além disso, alguns trejeitos de comportamento, as frases corridas e os passos largos foram planejados para dar uma idéia bem direta (nextel style) de ser.

Muito obrigado aos amigos pela ajuda e apoio na divulgação do vídeo.

WCF Parte II

Luciano Lima — Mon, 30 Aug 2010 14:24:16 GMT

Dando continuidade ao post anterior “Iniciando com WCF”, vamos ver hoje um pouco sobre a arquitetura WCF.

A figura 1 mostra a arquitetura principal do Windows Communication Foundation. Vamos ver cada item par que você possa começar a se familiarizar com o WCF.

Figura 1 – Arquitetura WCF

Contracts
O contrato expõe quais membros de uma classe serão visíveis. Através de interfaces podemos definir um contrato entre um serviço e as aplicações que irão consumí-lo, expondo somente os métodos desejados.

O WCF conta com os seguintes tipos de contratos:

Service Contract - Um contrato para um serviço. Define os detalhes do serviço, e será utilizado na interface de contrato.
Operational Contract - Define uma operação individual, e será aplicado na assinatura dos métodos da interface de contrato.
Data Contract - Define a serialização para objetos complexos. Esta propriedade necessita da inclusão do namespace System.Runtime.Serialization.
Message Contract - Este contrato descreve a mensagem SOAP completa.
Fault Contract - Utilizado para documentar erros no WCF.

Policies and Binding - Especifica as condições que serão requeridas para a comunicação, como exemplo podemos destacar os requisitos de segurança a serem utilizados na comunicação com o serviço.

Os contratos do WCF são utilizados como propriedades, podendo ser atribuído a classes e interfaces.

Service Runtime

Ele contém os comportamentos que ocorrem durante a execução do serviço.

- Throttling Behavior: controla quantas mensagens são processadas.
- Error Behavior: especifica um erro interno ocorrido no serviço.
- Metadata Behavior: informa como e se os metadados estarão disponíveis.
- Instance Behavior: especifica quantas instâncias do serviço deverão ser criadas durante a execução do serviço.
- Transaction Behavior: permite a reversão de operações caso uma falha venha a ocorrer.
- Dispatch Behavior: controla como uma mensagem é processada pela infra-estrutura do WCF

Messaging

A camada Message é composta de Canais. Canais são componentes que fazem o processamento das mensagens, por exemplo, autenticando uma mensagem.

Um conjunto de Canais é conhecido como Channel Stack. Os canais são o núcleo para o envio e recebimento de mensagens para um EndPoint.

Existem dois tipos de canais:

- Transport Channels: realiza o envio/ recebimento de mensagens pela rede. Ex.: HTTP, TCP e MSMQ.

- Protocol Channels: implementa o protocolo SOAP possibilitando a modificação da mensagem. Ex.: WS-Security e WS-Reliability.

Activation and Hosting

Para que um serviço possa ser consumido ele deve estar ativado e hospedado. No caso do WCF, este pode ser hospedado de diversas formas como:

IIS – Internet Information Service: provê várias vantagens como controle do serviço. Porém só pode ser utilizado o protocolo HTTP para o tráfego de informações.
Windows Activation Service - (WAS)
É uma forma mais atual de ser ativar um serviço, foi incorporado ao IIS 7. Trabalha com os seguinte protocolos: TCP e Named Pipes.
Self-Hosting
WCF Service pode ser hospedado também em um aplicativo do tipo Console Application, Windows Form ou aplicações gráficas WPF.
Windows Service
WCF também pode ser hospedado em um Serviço do Windows onde você pode ter o controle do aplicativo pelo Service Control Manager (SCM).

Como podem ver o WCF nos dá uma flexibilidade muito grande quanto a forma de hospedagem o que nos abre um enorme leque de possibilidades.

Aguardo vocês no próximo post!!

Enjoy!

Desvendando os segredos do VS - Testes de Unidade (Unit Tests)

André Castro — Fri, 27 Aug 2010 14:35:17 GMT

Fala Filhotes! Hoje vou mostrar mais uma utilidade dessa nossa versátil ferramenta. É a criação de Testes de unidade! Não sabe o que é um Teste de unidade? Bom… é um teste simples que tem como objetivo validar os dados de entrada e saída de um método, classe ou ate mesmo um objeto. Resumindo: É um teste para verificar que seu método ( no nosso caso ) está retornando o que ele deveria retornar.

Estou usando o Visual Studio 2010 mas o 2008 também possui essa ferramenta. Vamos ao exemplo então: Tenho um projeto de nome BOL dentro da minha solution com uma classe de nome Employee. Segue a classe abaixo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BOL
{

    /// 
    /// Classe Empregado (didático)
    /// 
    public class Employee
    {

        #region Enums

        /// 
        /// Enum com a função do empregado
        /// 
        public enum Role
        {
            Faxineiro,
            Gerente,
            Diretor
        }

        #endregion

        #region Propriedades

        public int codEmployee { get; set; }

        public string NameEmployee { get; set; }

        public Role RoleEmployee { get; set; }

        public double Salary { get; set; }

        /// 
        /// Retorna a hora extra, que é o salario dividido por 28 vezes 1.5
        /// 
        public double HoraExtra
        {

            get { return (Salary / 28 * 1.5); }
        }

        #endregion

        #region Construtores

        public Employee()
        {
        }

        #endregion

        #region Metodos Estaticos
        /// 
        /// Verifica se o salario do empregado esta adequado com o do mercado
        /// 
        /// Retorna True se esta e False se não
        public static bool CheckSalary(Employee empregado)
        {
            //
            // Checa qual o emprego do empregado
            // Para verificar se o salario é compativel com o do mercado
            //
            switch (empregado.RoleEmployee)
            {
                case Role.Faxineiro:
                    if (empregado.Salary > 700)
                        return true;
                    break;

                case Role.Gerente:
                    if (empregado.Salary > 2600)
                        return true;
                    break;

                case Role.Diretor:
                    if (empregado.Salary > 4000)
                        return true;
                    break;
            }

            return false;

        }

        /// 
        /// Quanto o empregado recebe em 7 dias de serviço
        /// 
        /// Objeto do tipo Employee
        public static double GetWeeklyPayment(Employee empregado)
        {

            var total = empregado.HoraExtra * 7;

            //
            // Retorna o valor total 
            //
            return total;
        }

        #endregion

    }

}

Como você podem ver essa é uma classe simples com 2 métodos estáticos, uma propriedade só de leitura ( Hora Extra ) e o resto de propriedades normais.
Então agora nós iremos criar os testes para esses dois métodos e para nossa propriedade “Hora Extra”.
Mas como isso? Basta clicar em algum lugar dentro da classe Employee e depois em “Create Unit Tests”

Reparem que aparece uma nova tela mostrando os itens da sua classe. Nessa tela você escolhe os métodos/propriedades para quais serão criados os testes de unidade. Então vamos selecionar só os nossos métodos e nossa propriedade “Hora Extra”.

Veja que no Output project você tem a opção de criar um novo projeto de testes, ou se nós tivéssemos, poderíamos usar um projeto já existente. Podemos configurar como será gerado nossa classe de testes clicando em Settings:

Você pode ver que o nome do arquivo e da classe é por padrão o nome da sua classe mais a palavra Test, você pode mudar a nomenclatura da maneira que você quiser. Vamos ver o que cada opção faz:

Mark all test results Inconclusive by default – Se você não modificar os testes que serão gerados, eles iram retornar inconclusivo, isso é uma maneira de mostrar ao programador que ele tem que alterar o teste. (Será dado o exemplo mais abaixo)Enable generation warnings – De acordo com o site da MSDN essa função não está ativa.
Globally qualify all types – Gera as variáveis com o qualificador global ( [namespace].[variável] ) para evitar ambigüidade entre tipos.
Enable documentation comments – Habilita a geração dos comentários para cada método.
Honor InternalsVisibleTo Attribute – Se você marcar essa opção, os métodos marcados como Friend ou Internal serão tratados como métodos públicos.
Lembrando que se você estiver usando o Visual Studio 2008 ou 2005 as opções podem ter nomes diferentes, mas funcionalidades iguais ou parecidas.

Depois de escolher as opções basta apertar OK. E OK na tela de criar os testes.

Se você criou um novo projeto escolha um nome para ele e aperte em Create.
Você pode reparar que um novo projeto de testes foi criado na sua solution com uma classe com o nome que definimos mais acima. Também pode ver que ela criou os métodos de testes que você pediu. Vamos usar o método CheckSalaryTest como exemplo de como o método é:

  	/// 
        ///A test for CheckSalary
        ///
        [TestMethod()]
        public void CheckSalaryTest()
        {
            Employee empregado = null; // TODO: Initialize to an appropriate value
            bool expected = false; // TODO: Initialize to an appropriate value
            bool actual;
            actual = Employee.CheckSalary(empregado);
            Assert.AreEqual(expected, actual);
            Assert.Inconclusive("Verify the correctness of this test method.");
        }

Perceba os “//TODO ” o visual studio já marcou isso para você saber que você tem que inicializar a variável com algum valor, perceba que por padrão a variável esta nulo. Então nós temos que substituir isso pelo valor a ser testado:

Employee empregado = new Employee { NameEmployee = "Andre", Salary = 800, RoleEmployee = Employee.Role.Faxineiro };

Percebam que existe uma variável com o nome de “expected“ no nosso método de testes, o conteúdo dessa variável deve ser o valor que nós esperamos alcançar. Como assim? Bom, o método que nós vamos chamar não é o CheckSalary? Lembrando, o CheckSalary checa se o meu salário é adequado com o do mercado. Então se mandarmos esse nosso objeto, ele deveria retornar True já que o “André” é um faxineiro e ganha mais que o piso salarial (700) de acordo com o método. Então o valor da variável expected será True. Ótimo! Perceba que o resto do código é a simples execução do método e mais uma comparação do resultado obtido (actual) com o esperado (expected) mas espere, e aquele “Assert.Inconclusive” ? Lembra da configuração que fizemos mais cedo? Se você executar esse teste agora ele retornará como inconclusivo. Basta tirar essa linha e estaremos pronto para ir! Olha como ficou o nosso método depois de toda essa configuração:

	/// 
        ///A test for CheckSalary
        ///
        [TestMethod()]
        public void CheckSalaryTest()
        {
            // 
            // Crio um novo empregado para fins de testes
            //
            Employee empregado = new Employee { NameEmployee = "Andre", Salary = 800, RoleEmployee = Employee.Role.Faxineiro };
            //
            // O resultado que esperamos é um true
            //
            bool expected = true; 
            bool actual;
            actual = Employee.CheckSalary(empregado);
            Assert.AreEqual(expected, actual);
        }

Beleza, mas e agora? Como executamos isso? Vários jeitos... Podemos executar um de cada vez usando esse “botãozinho” ao lado de cada método:

Ou usamos os ícones na nossa toolbar para executar todos os testes de uma vez.

E depois de executar, é só conferir o resultado.

E se falhar:

Simplesmente aperte com o botão direito e “View Test Results Details” para abrir os detalhes juntamente com a exceção que aconteceu:

Existem outras ferramentas do Visual Studio para melhorar a qualidade dos testes, maior informação dos resultados e etc… Mas não pretendo falar sobre eles agora, senão o post iria ficar muito longo e confuso. Então por hoje é isso! E claro, você pode colocar esse projeto de testes no TFS também.

Então, nós vimos que graças ao Visual Studio podemos criar testes de unidade com “meia dúzia” de cliques, algo muito útil na vida de um desenvolvedor.

Espero que vocês tenham gostado, já vou seguir o meu caminho, até mais.

Edit: Alterado o nome de testes unitários para testes de unidade. Dica do @Camiloribeiro. Obrigado!

Iniciando com WCF

Luciano Lima — Thu, 26 Aug 2010 01:22:04 GMT

Fala pessoal, tudo na paz?

Bem, como ando recebendo e-mails da galera perguntando sobre WCF, resolvi escrever alguns artigos sobre ele.

Nessa primeira parte vamos ver o que é o WCF e o que o compõe. Será uma introdução básica, porém, espero colocar toda informação necessária para um primeiro contato.

Primeiramente, o que é o WCF?

Windows Communication Foundation ou WCF como é mais conhecido nada mais é do que um SDK para desenvolvimento de aplicações distribuídas e orientadas a serviço, também conhecidas como (SOA).

O WCF surgiu no .Net Framework 3.0. Ele veio para unificar tecnologias como COM+, .Net Remoting, Web Services e MSMQ (Microsoft Message Queue), isso porque, antes do WCF, era necessário que o desenvolvedor utilizasse tecnologias distintas para cada tipo de aplicação, um exemplo seria a criação de Web Services para disponibilizar na Internet algum serviço. Caso este serviço fosse disponibilizado na intranet, deveria ser criada uma aplicação utilizando .Net Remoting, isso porque .Net Remoting utilizava o protocolo TCP enviado arquivos binários pela rede o que tornava a aplicação muito mais rápida do que com Web Service (Http/XML). Com a criação do WCF isso deixa de existir, ele torna a vida do programador muito mais simples.

Para que possamos criar, projetar e implantar serviços WCF, devemos nos ater a alguns conceitos básicos que são os EndPoints e seus componentes ( Address, Binding e Contract).

Toda comunicação com o serviço se dá através dos EndPoints, são eles os responsáveis por fornecer aos clientes o acesso às funcionalidades do serviço.

Calma pessoal não se assustem, vamos ver em detalhes cada pedacinho que compõe um EndPoint. Vamos lá?

Address

Nada mais é do que o local ou endereço onde o serviço reside. O Address possui dois pontos importantes que são a localização e o protocolo de transporte. Um Address possui o seguinte formato:

[base address]/[optional URI]

Já o base address segue o seguinte formato:

[transport]://[machine or domain][:optional port]

Como transport, o WCF nos oferece os seguintes canais de comunicação:

http, https, net.tcp, net.pipe, net.msmq e net.p2p

Para ilustrar melhor abaixo temos alguns exemplos de Address:

http://localhost:8080
http://localhost:8080/MeuWCFService
net.tcp://localhost:123/MeuWCFService
net.pipe://localhost/MeuWCFService
net.msmq://localhost/private/MeuWCFService
net.msmq://localhost/MeuWCFQueue

Binding

É o responsável por definir como será a comunicação com o serviço (tcp, ipc, http, msmq, etc).
O WCF nos oferece seis tipos de binding que são:

- BasicHttpBinding
- NetTcpBinding
- NetNamedPipeBinding
- WSHttpBinding
- WSDualHttpBinding
- NetMsmqBinding

Para saber mais sobre Binding, deem uma olhada no post WCF Bindings.

Contract

No contrato é onde definimos quais funcionalidades um serviço irá expor para os clientes.
Existem quatro tipos de contrato que são:

Service Contracts:
- define quais operações estarão disponíveis no serviço para o cliente., ou seja, mapeia tipos CLR para WSDL

Data Contracts:
– define a estrutura de dados usada no serviço, ou seja, ele mapeia tipos CLR para XSD

Fault Contracts:
- define os tipos de erros que serão lançados pelo serviço e como eles irão propagar para o cliente.

Message Contracts:
- define a estrutura de mensagens usadas no serviço, ou seja, mapeia tipos CLR para SOAP

Então, para que tenhamos um EndPoint precisamos ter um Address, um Binding e um Contract, estes itens são conhecidos como ABC´s EndPoint.

Bem pessoal, por hoje é só!

Em nossos próximos posts iremos nos aprofundar um pouco mais no WCF.

Espero que tenham gostado desta primeira parte.

Enjoy!!

Tech-Ed, o evento dos palestrantes feras

Ivan Paulovich — Tue, 24 Aug 2010 03:36:19 GMT

Eu estou concorrendo a uma vaga para palestrante do Tech-Ed Brasil 2010. E o vídeo abaixo é uma produção onde eu provo por quê eu devo ser um palestrante do Tech-Ed. Assistam o vídeo:

Nesse vídeo de apenas 2 minutos (tempo curtíssimo) eu mostro algumas características fundamentais de um palestrante. São elas:

Ter habilidade para falar em público.
Possuir conhecimento teórico e experiência prática.
Ser um influenciador Microsoft na sua região.

Na sequência eu defendo por quê eu (Ivan Paulovich) tenho essas características. Vejam o vídeo e entendam.

Making Of

Aposto que vocês devem estar imaginando que criar um vídeo desses é simples e rápido. Mas eu tenho que lhes dizer que não foi tarefa fácil. Como eu optei por fazer um vídeo a céu aberto estávamos sujeitos ao ambiente e em todos os lugares que gravamos haviam dezenas de pessoas.

Com a ajuda dos meus amigos gravei vídeos em várias partes da cidade.

Gravei vídeos na Praça do Papa, depois no Parque das Mangabeiras, fiz alguns takes na orla da Pampulha, na Casa do Baile e no final optei por um vídeo numa rua deserta bem perto da minha casa ;-)

(A esquerda eu na Praça do Papa)

Umas das coisas boas dessas filmagens foi passear pela cidade em busca de lugares legais de Belo Horizonte que pudessem compor o vídeo.

(A esquerda eu no Parque das Mangabeiras)

Gravamos várias vezes usando passinhos de ninja. Nessa técnica enquanto eu ando em direção a câmera o cinegrafista dá passos para traz. Parece súper tranquilo na teoria más na prática a imagem fica muito tremida.

Tentamos várias vezes até que minha namorada (Contra-Regra) teve a brilhante idéia de colocar o André Paulovich (Cinegrafista) sentado no porta-malas do carro para diminuir as trepidações do vídeo.

Submetemos a idéia ao André Paulovich (Diretor) e ele aprovou os recursos tecnológicos e logo colocamos tudo em prática ;-)

Vejam só a foto que tirei do nosso carrinho de filmagem:

Na foto minha namorada e meu irmão André Paulovich estão preparados para mais uma filmagem. E dessa geringonça saiu o vídeo final.

Agora que temos o vídeo gravado. Passamos o trabalho para o João Paulo (Editor de Áudio e Vídeo) criar uma abertura interessante, colocar legenda, colocar alguns elementos gráficos que pudessem traduzir o que eu defendia e também tratar o áudio.

Nessa foto André Paulovich acompanha os últimos detalhes da produção enquanto o João Paulo sincroniza as legendas e prepara para o “Go Live”!

Temos a obrigação e o prazer de agradecer ao grupo Delirious por mandarem um som tão maneiro. Se você curtiu o som da abertura e de fundo do vídeo assista esse clip:

E você, aprovou a minha candidatura ao Tech-Ed? Então tuíte o seguinte texto e eu te agradeço desde já:

@ivanpaulovich http://www.youtube.com/watch?v=kMoZDlnWQlc #TechEdBR #EventoDeFeras

Muito obrigado João Paulo, André Paulovich e Bárbara!

Alguns Retuítes da Comunidade

Update 24 de Agosto.

Desvendando os segredos do VS - Atalhos

André Castro — Fri, 20 Aug 2010 11:15:55 GMT

Faaalllaaaaaa Filhoteess! Cês tão bão?

Então, hoje eu vou começar a explicar algumas funcionalidades “Ocultas” da nossa principal ferramenta, o Visual Studio!
Como vocês sabem o Visual Studio tem ~~uma cassetada~~ varias funcionalidades que muitas vezes nós não usamos, não que elas sejam inúteis, longe disso, o fato é que nós não somos acostumados a usar algo mais do que o BUILD ou EXECUTE. Bom… vou mostrar para vocês 10 atalhos muito úteis que irão facilitar suas vidas!

F12 - Go to Definition
Leva o cursor para a origem do método/variável. Muito útil para quando você quer saber o que aquele método faz ou aonde você esta declarando aquela variável.

Ctrl + “–” e Ctrl + Shift + “-“ - Backward e Forward
Volta (Ctrl + “-”) o cursor para o ultimo lugar onde ele estava funciona igual aos botões de voltar e avançar do browser.

Ctrl + Shift + F9 – Delete all Breakpoints
Sabe quando você esta “atrás” de algum erro e enche de breakpoints o código, e quando você resolve o erro os breakpoints ainda estão lá? Então… Com esse atalho você deleta TODOS os breakpoints da solution.

Ctrl + M + M – Collapse
Você pode dar um collapse (recolhida) no método aonde você está, deixando–o como um bloco de código que pode ser expandindo novamente usando o mesmo atalho.

Alt + Enter – Open Properties
É só clicar em um projeto e apertar Alt + Enter para abrir as propriedades do mesmo, alias isso abre a propriedade de quase tudo no windows e isso funciona ate no windows explorer.

Ctrl + B + T – Bookmark
Adiciona / Remove a linha atual à uma espécie de “favoritos” aonde você pode navegar entre essas linhas pelos atalhos abaixo.

Ctrl + B + N e Ctrl + B + P – Next / Previous Bookmark
Navega entre os bookmarks, ótimo para quando você tem trechos do código que você sabe que você vai acabar tendo que voltar para terminar ou adicionar algo.

Shift + F12 – Find Usages
Esse atalho é excelente! Você usa esse atalho em cima de algum método/variável e aparece uma tela mostrando TODOS os lugares em seu código que você está invocando esse método.

Ctrl + K + C e Ctrl + K + U - Comment e Uncomment
Comenta (Ctrl + K + C) e “descomenta” (Ctrl + K + U) as linhas selecionadas. Muito útil quando você acostuma.

Ctrl + K + D e Ctrl + K + F - Reformat Document / Code Block
Sabe quando o seu código vai ficando desorganizado a medida que você vai codificando? Então, seus problemas acabaram! Pois com esses atalhos você formata todo o código ( Ctrl + K + D) ou só uma parte (Ctrl + K + F) de uma vez!

A sim, esses atalhos foram testados nos Visual Studio 2008 e Visual Studio 2010, e sei que vários funcionam no Visual Studio 2005 também, mas não sei são todos.

Então é isso ai! Eu uso bastante esses atalhos e espero que vocês tenham encontrado algum atalho útil. Qualquer dúvida me avisem! Ate mais filhotes!

C# Extension Methods

Luciano Lima — Thu, 19 Aug 2010 13:36:30 GMT

Outro dia estava trabalhando em um projeto onde precisava criar alguns métodos a mais para uma dll que havia sido gerada para um outro aplicativo. Porém, como não tinha o código fonte dela estava prestes a escrever uma nova classe e implementar os métodos que estava precisando, mas antes de começar a codificar, me lembrei que a partir da versão 3.0 do Net Framework, a Microsoft incluiu uma funcionalidade muito bacana chamada Extension Methods.

Mas o que são Extension Methods?

Basicamente é uma forma de você “inserir” código em classes já compiladas mesmo que estas sejam seladas (sealed) como a maioria das classes do .Net Framework. Desta forma podemos incrementar nossas classes com métodos que criamos sem a necessidade de realizar uma recompilação da mesma.

Mas para que isso fique mais claro, vamos ao exemplo.

Crie um projeto do tipo C# -> Console Application, dê o nome de “ExtensionMethods”.

Agora crie um novo projeto do tipo C# –> Class Library, e dê o nome dele de MyClass. Agora renomeie a Class1.cs para Client.cs. Seu projeto deverá estar como na figura 01.

Figura 01 – Solution Explorer

Agora, abra o arquivo Client.cs e adicione o código da listagem 01.

Listagem 01 – class Client.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyClass
{
    public sealed class Client
    {
        public string Name { get; set; }
        public string Email { get; set; }

        public bool EmailIsValid()
        {
            return !string.IsNullOrEmpty(Email);
        }
    }
}

Observem que criamos duas propriedades e um método que “valida” o email do cliente.

Vamos criar nossa chamada à classe Client. Abra o arquivo Program.cs e insira o código da listagem 02 no método Main da classe.

Listagem 02 – chamada a classe Cliente

var cl = new Client
              {
                 Email = "lima@lucianolima.com.br",
                 Name = "Luciano Lima"
              };

    Console.WriteLine( cl.EmailIsValid() ? "Email Válido" : "Email Inválido" );
    Console.ReadLine();

Ao executar este código ele irá apenas escrever Email Válido porque a propriedade Email está preenchida.

Bem, digamos que você precise realizar a validação do Nome do Cliente, mas sem ter que mexer na classe Client, é ai que Extension Methods entra em ação.

Adicione uma nova classe no projeto ExtensionMethods, dê o nome a ela de “ClientExtension.cs” e insira o código da listagem 03.

Listagem 03 – class extension

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MyClass;

namespace ExtensionMethods
{
    public static class ClientExtension
    {
        public static bool NameIsValid(this Client client)
        {
            return !string.IsNullOrEmpty(client.Name);
        }
    }
}

O importante nessa classe é a forma como criamos o método, observem que o segredo para a funcionalidade de extensão é a palavra “this” que faz referencia à classe que queremos agregar operações, o restante é código puro e simples.

Agora quando for utilizar a funcionalidade, o Visual Studio irá detectar que este método é uma extensão para a classe Client, conforme figura 02 e figura 03.

Figura 02 – método estendido na classe Client

Figura 03 – ToolTip mostrando que o método é uma extensão.

Extension Methods como falei acima pode ser aplicado a todas as classes do dot Net Framework, então caso precise de um método exclusivo para trabalhar com string basta criar sua classe de extensão e implementar o método que achar necessário. Mas cuidado, a manutenção deste tipo de código pode ser um pouco árdua por isso, pense bem antes de sair criando extension methods.

Enjoy!!

Paulovich.Data passa os 1500 downloads

Ivan Paulovich — Thu, 19 Aug 2010 12:36:32 GMT

Paulovich.Data é um framework de persistência para múltiplos datasources e fácil de usar. Você já deve ter ouvido falar muito dele aqui no blog.

O que você não sabe é que o Paulovich.Data é um framework usado por diversas pessoas no Brasil e também no exterior. Veja o gráfico de downloads ao longo do ciclo de vida do projeto.

Passamos dos 1500 downloads e temos aproximadamente 1 download por dia. Não é muito. Mas para um projeto que começou como um estudo de ADO.NET e se transformou em algo útil a tantas empresas e profissionais deixa todos que participam do projeto muito felizes. Obrigado!

O Paulovich.Data é hospedado no Codeplex. A Microsoft mantém esse serviço e permite que seus usuários utilizem as melhores tecnologias para desenvolvimento de software colaborativo. Experimente você também, tenha uma idéia e divida ela com a comunidade.

Criando Indexadores (Indexers)

André Castro — Wed, 18 Aug 2010 13:54:13 GMT

Eai filhotes, tudo bem?

Hoje vou mostrar como se cria indexadores! Não sabe o que é um Indexador? Um indexador basicamente deixa sua classe com um comportamento semelhante ao de um array, deixa eu dar um exemplo:

Você consegue acessar um item de um array/collection apenas passando o ID/KEY:

 meuArray[1] = "teste";

O Indexador deixa nossa classe com esse comportamento. Então vamos ao que interessa!!

Para criar o indexador numa classe basta você criar a seguinte propriedade:

  public TIPO this[int index]
    { ...

Aonde o TIPO é o tipo do objeto/retorno, e o parâmetro pode ser qualquer tipo (Int, String, …) e ate mais de um (para matrizes ou etc…) , no nosso caso usaremos um inteiro para pegar o índice.

Criei duas classes para dar um exemplo:

/// 
/// Propriedades Genéricas
/// 
public class GenericProperty
{
    public enum DbType
    {
        Varchar,
        Int,
        Bit
    }
	public GenericProperty()
	{
	}

    public string Name { get; set; }

    public DbType Type { get; set; }

    //Faço um Override no ToString para poder mostrar o Nome do campo e o tipo na hora de invocar o ToString.
    public override string ToString()
    {
        return Name + " [" + Type + "]";
    }  
}

/// 
/// Classe com todas as propriedades genericas
/// 
public class PropertyControl
{
    // Coleção com as propriedades genericas
    private Collection<GenericProperty> colProp;

    //Nosso INDEXER do tipo GenericProperty
    public GenericProperty this[int index]
    {
        get { return colProp[index]; }

        set { colProp[index] = value; }
    }

    //Método que adiciona o item à coleção
    public void AddItem(GenericProperty newProp)
    {
        colProp.Add(newProp);
    }

    // Meu construtor tbm instancia a collection
    public PropertyControl()
    {
        colProp = new Collection<GenericProperty>();
    }
}

E pronto… como podemos ver abaixo, usamos nossa classe como uma array:

	
	//Instanciamos nossa Classe
        var ObjTeste = new PropertyControl();
	
	// Adiciona os itens 
	// Usando as chaves "{" na hora de criar um novo objeto, eu posso setar as propriedades do mesmo, sem precisar de um construtor
        ObjTeste.AddItem(new GenericProperty { Name = "Nome", Type = GenericProperty.DbType.Varchar });

        ObjTeste.AddItem(new GenericProperty { Name = "Idade", Type = GenericProperty.DbType.Int });

	// Alterando o valor pelo index, como se fosse uma collection normal
        ObjTeste[0].Name = "Endereco";        

        // Jogo no label o valor do nosso objeto, que vai ser "Idade [Int]"
        labelTeste.Text = ObjTeste[1].ToString();

Muito legal… Usando os indexadores nós temos a mesma comodidade de uma collection/array e também evitamos expor nossa collection, além de poder criar métodos de conversões no GET / SET do Indexador. E claro os Indexadores podem ser sobrecarregados.

Bom, espero que tenha ficado claro. Um bom dia para você e ate mais.

E para finalizar: pretendo estar mais presente no blog a partir de agora!

Fonte: http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx

Update: Resolvido problemas no case-sensitive.

Community Zone 2010: presença confirmada

Ivan Paulovich — Tue, 17 Aug 2010 13:17:46 GMT

Acabei de receber o convite para participar do Community Zone 2010 (2º Edição!). O Community Zone é um evento onde a Microsoft reúne quem mais atua na comunidade para discussão e integração.

Nessa edição do evento eu irei com alguns estreantes de CZ André Paulovich e André Castro (finalistas da Copa Microsoft de Talentos).

O evento desse ano promete! Estamos curiosos e ansiosos pelas atividades que teremos. E se você vai no evento ou tem curiosidade sobre o que é acompanhe a hashtag #CommunityZone ou siga-nos no twitter.

Atualizado em 19 de agosto

O Fabio Hara postou em seu blog algumas informações importantes sobre o Community Zone 2010. Dê uma lida nas perguntas mais frequêntes e siga-o no twitter.

Parabéns pra mim!

Ivan Paulovich — Tue, 17 Aug 2010 12:53:36 GMT

Hoje comemoro 24 anos de vida e já comecei o dia muito bem com algumas excelentes surpresas. Vejam só algumas fotos da festa de aniversário que minha namorada preparou pra mim no trabalho:

Na foto estão, Fernando, Ricardo Cruz, Wescley, Renato Lima, Alex Alves, Ivan Paulovich (Eu), Danielle Almeida, Giovanni, André Paulovich e João Paulo.

Na foto estão, Ricardo Cruz, João Paulo, Fernando Miranda, Wescley, Renato Lima, André Castro, Giovanni, Danielle, André Paulovich, e Luciano Lima.

Eu ainda vou comemorar meu aniversário nesse sábado. Me manda um e-mail que eu te passo detalhes do lugar e da hora. Ou então me liguem.

Lógica de programação

André Paulovich — Thu, 12 Aug 2010 22:17:00 GMT

Hoje vamos começar com o ponto fundamental de todo processo de desenvolvimento: Lógica de programação. Afinal, todos que esperam algum dia criar um sistema precisam desenvolver seu raciocínio lógico. Mas o que é Lógica? Bem, não é fácil definir o que é lógica sem usar um jargão ou uma destas definições de livros acadêmicos, por isso, vou usar uma definição que encontrei na wikipedia: "...a lógica é o ramo da filosofia que cuida das regras do bem pensar, ou do pensar correto, sendo, portanto, um instrumento do pensar". Viram como é difícil? Mesmo a definição da wikipedia é bastante confusa, mas podemos perceber que a lógica esta diretamente relacionada ao raciocínio.

É justamente neste ponto que começa todo desenvolvimento de sistemas. Pois, um sistema nada mais é do que a união de várias pequenas soluções de problemas. E para resolver problemas precisamos raciocinar. Todo desenvolvedor de sistemas precisa antes de mais nada saber "lógica de programação", ou seja, precisa saber aplicar seu raciocínio na construção de algorítimos. Mas o que são algorítimos?

Um algoritmo é a seqüência finita de passos que levam a execução de uma determinada tarefa. Ou seja, podemos pensar em algoritmo como uma receita ou um manual que mostra a seqüência de instruções resultam na execução desta tarefa. E não importa qual for a tarefa, até mesmo as coisas mais simples da vida cotidiana podem ser traduzidas em algorítimos. Imagine que você vá tomar um banho. Como seria o algorítimo da tarefa "Tomar banho"? Talvez seja mais ou menos assim:

- Início
1) Tirar a roupa.
2) Ligar o chuveiro.
3) Entrar na água.
4) Passar sabonete.
5) Enxaguar.
6) Desligar o chuveiro.
7) Enxugar.
- Fim

Mas não podemos simplesmente dizer a um computador: "Calcule meu imposto de renda" ou "Controle o meu estoque". Por isso precisamos saber escrever estes algorítimos numa língua que ele compreenda. É neste ponto que muitas pessoas se "desesperam" e pensam: "Ai caramba! Eu tento aprender a falar inglês desde que tenho 5 anos e até hoje não consigo falar nada além de 'the sky is blue' ou 'the book is on the table'... como vou aprender mais uma língua?!". Calma! Aprender uma linguagem de programação não é um bicho de sete cabeças. Como tudo na vida exige apenas um pouco de dedicação, mas não vamos entrar neste mérito, pois já discutimos estes aspectos em nosso primeiro post. Felizmente, para facilitar as coisas vamos utilizar um "pseudocódigos" escritos em PORTUGOL, que é uma espécie de linguagem de programação baseada em verbetes de comando em Português, e portanto de fácil compreensão.

Como qualquer linguagem de programação, o PORTUGOL, que apesar de ser uma base de nosso "pseudocódigo", exige que sigamos uma série de regras na construção do nossos algorítmos. Podemos resumir rapidamente estas regras da seguinte forma:

Usar somente um verbo por frase.
Escrever o código mais simples possível.
Usar frases curtas e simples.
Ser objetivo

Então prepare-se, a partir de nosso próximo post, vamos escrever algorítimos pra valer. Um abraço a todos e bons estudos.

Curso de programação

André Paulovich — Thu, 12 Aug 2010 19:40:56 GMT

Olá amigos, esta é a segunda vez que tentarei realizar este curso… para tentar concluir este propósito vou contar com a ajuda de algums amigos. Um deles é o Ricardo Cruz, analista de sistemas e blogueiro aqui do 100loop. No futuro teremos outras pessoas escrevendo para a série de posts do curso.

A razão para realizar o curso, é a que tenho conversado com alguns amigos; muitos deles até acompanham assuntos de tecnologia… são capazes de alterar um “programinha pronto” em alguma linguagem de programação. Mas a grande maioria vive me perguntando como aprender a "programar de verdade" para criar algo do zero, dominando os conceitos e por consequência… aprender qualquer linguagem mais rapidamente.

Pensando nisso, imaginei criar uma série de posts para discutir conceitos básicos de desenvolvimento; começando desde lógica, sintaxe, algorítimos e afins... para que possa servir de apoio a qualquer pessoa que se interesse por programação e não sabe por onde começar.

Pensei em começar escrevendo sobre "lógica de progamação" como nosso primeiro fundamento. Mas antes gostaria de avisar a todos que forem acompanhar estes posts que nada acontece da noite para o dia... ninguém que leia este blog irá aprender a programar em poucas semanas, só porque leu alguns posts e acompanhou algumas discussões. Tudo leva tempo. Há um tempo atrás, li um artigo muito interessante do Peter Norvig (traduzido pelo Augusto Radtke) que tem o intrigante título "Aprenda a programar em 10 anos". A primeira vista pode parecer um texto desanimador para quem está querendo começar agora, ainda mais numa sociedade imediatista como a nossa... movida a "fast food", "fast shop"... "fast tudo", mas acredite, se você realmente quer aprender, tenha paciência, trace um objetivo e dedique-se de verdade.

Uma boa dica para os iniciantes é traçar uma meta. Saiba perfeitamente onde você quer chegar. Por exemplo, se você trabalha com vendas, tente programar para um dia conseguir fazer um sistema que lhe ajude a controlar seu fluxo de caixa; ou mesmo que controle suas despesas do mês. Este pode ser o objetivo que vai lhe inspirar a continuar aprendendo. Não tenha medo de pensar algo assim, mas lembre-se do primeiro ponto deste texto... tenha paciência, pode ser que você só venha a conseguir completar este programa em 2 anos... talvez em 6 meses. Só depende de você.

Outro ponto fundamental é não se enganar, conheci muitas pessoas que tem extrema dificuldade em reconhecer que não domínam determinado assunto. Não sei o quanto isso é comum em outras áreas, mas na área de tecnologia, alguns profissionais não conseguem admitir que não sabem resolver um determinado problema sozinhos e preferem não pedir ajuda. Um grande profissional da área de tecnologia exercita não apenas sua comunicação com os computadores, mas principalmente com outros profissionais. Algo parecido acontece quando, decidimos atropelar nossos estudos passando para outro assunto sem ter concluído (entenda que conclúido é "dominado") o assunto anterior. E claro, isto se encaixa perfeitamente no outro fundamento: mantenha contatos com pessoas que já programam, pois elas irão lhe ajudar a avaliar seus conhecimentos, lhe darão suporte quando você tiver dúvidas e quem sabe um dia vocês não trabalhem juntos?

Tentarei participar ativamente de tudo isso que falei para aqueles que se dispuserem a participar do grupo... escreverei, postarei dicas, responderei perguntas e estarei à disposição sempre que possível. Então nos vemos em breve para iniciarmos nossos estudos... e espero poder contar com outros grandes profissionais nesta tutoria on-line. Um grande abraço a todos.

Leitor de RSS para ASP.NET mais simples que existe

Ivan Paulovich — Wed, 11 Aug 2010 15:56:34 GMT

O código abaixo é um leitor de RSS para ASP.NET e você pode colocar em praticamente todo site ASP.NET que permita acrescentar User Controls.

<%@ Control Language="C#" AutoEventWireup="True" Inherits="System.Web.UI.UserControl" %>
<%@ OutputCache Duration="600" VaryByParam="None" VaryByControl="None" %>

<script runat="server">
    public string Url
    {
        get { return Rss.DataFile; }
        set { Rss.DataFile = value; }
    }
</script>

<asp:Repeater ID="List" runat="server" DataSourceID="Rss">
    <HeaderTemplate>
        <ul>
    </HeaderTemplate>
    <ItemTemplate>
        <li>
            <asp:HyperLink ID="title" runat="server" 
                NavigateUrl='<%# XPath("link") %>' Text='<%# XPath("title") %>'></asp:HyperLink>
        </li>
    </ItemTemplate>
    <FooterTemplate>
        </ul>
    </FooterTemplate>
</asp:Repeater>

<asp:XmlDataSource CacheDuration="600" ID="Rss" 
    runat="server" XPath="/rss/channel/item">
</asp:XmlDataSource>

Para instalar no seu site basta que você insira código semelhante a esse:

<%@ Register TagName="RssFeed" TagPrefix="Extra" Src="~/Controls/RssFeed.ascx" %>

E em qualquer parte da sua página você pode usar o controle com um código assim:

O perfil que realmente importa

André Paulovich — Tue, 10 Aug 2010 20:06:49 GMT

Esta semana tirei umas horinhas para atualizar meus perfis de redes sociais, e logo após a primeira meia hora de “trabalho duro”, me peguei pensando sobre a importância de manter todos estes perfis atualizados. Na verdade, quando a gente mantêm estes dados online… com uma vasta gama de informações sobre nós, existe uma razão para isso: Queremos ser vistos! E é neste ponto que queria “trocar uma idéia” com vocês. Eu particularmente possuo: orkut, facebook, linked-in, twitter… etc. Mas afinal, qual deles realmente importa?!

É claro que todos cumprem objetivos diferentes, mas se você não tem tempo para ficar horas atualizando seus perfis online, escolha bem aquilo que você está alimentando no seu “Ego-google” (que nada mais é do que aquilo que o google diz sobre você, experimente pesquisar seu nome no google: é bem divertido). Mas voltando ao assunto, é preciso ter muito cuidado com aquilo que postamos na internet, afinal não temos muito controle daquilo que o google diz sobre nós.

Mas porque estou dizendo isso? Bom, já participei de vários processos seletivos, e acho que não é segredo para ninguém que muitos dos empregadores costumam pesquisar a vida dos candidatos no google… vasculhando orkut, facebook e o que mais puder encontrar. Nada mais natural, a gente sempre procura coisas boas… trabalhos de faculdade, projetos publicados, áreas de interesse (de preferência na área pleiteada)… mas é claro que as vezes encontramos o que não queríamos… do tipo: associações com comunidades, no melhor estilo “odeio trabalhar na segunda-feira” ou “meu chefe é um pé no saco”. Não quero de forma alguma criar uma polêmica sobre o que se faz fora da empresa, mas apenas alertar sobre os perigos de manter perfis deste tipo disponíveis e abertos para TODO MUNDO ver. Afinal, a grande maioria destas redes possuem mecanismos de controle de privacidade e DEVEM ser utilizados.

Veja meu “ego-google” como está neste momento…

E então para minha surpresa, os dois primeiros links que o google vincula ao meu nome são justamente da rede social que eu mais gosto, o Linked In. Afinal, é a rede social mais produtiva para quem usa… pois é uma maneira simples de deixar o seu currículo disponível online para quem quizer ver, o sistema permite ainda que você se associe aos grupos de empresas, profissionais ou instituições de ensino… podendo ainda fazer o famoso QI (“quem indica”)… já que você pode recomendar ou ser recomendado por colegas de trabalho. Ou seja, um prato cheio para “head hunters”… espalhados pelo país a fora. Eles podem estar procurando por você.

Mas isso é apenas uma parte do seu “ego-google”, é sempre bom manter conteúdo de relevância sobre você ou de sua autoria. No meu caso, participar do 100loop escrevendo artigos técnicos, participar como palestrante e divulgar eventos no DotNetRaptors além de ser um hobbie e trazer beneficios para a comunidade… é em contra partida, um ótimo marketing pessoal. E é aí que que todos os entusiastas da comunidade sempre batem na mesma tecla… “participe da comunidade ativamente, você vai colher frutos no futuro”. Este “futuro” pode ser muito antes do que você imagina… e este “fruto” nada mais é do que o reconhecimento merecido pelo seu trabalho, pois o MERCADO está te vendo.

Você precisa apenas tornar as coisas mais fáceis para quem te procura. Acompanhe regularmente seu “ego-google”, mantenha aquilo que diz respeito apenas para os seus amigos mais íntimos, como privados (para evitar mau-entendidos)… e principalmente valorize o seu perfil profissional: é ele que realmente importa.

Daí vão algumas dicas rápidas:

Responda fóruns, escreva artigos e participe de um blog.
Tenha um perfil no linked in atualizado.
Procure manter um currículo online.
Mantenha sua vida pessoal, “privada”.

um abraço à todos, e divirtam-se.

Design Pattern TSF - Telefone Sem Fio

Luciano Lima — Mon, 02 Aug 2010 19:29:52 GMT

Hoje vamos mudar um pouco nossas conversas, não vamos falar nem mostrar uma linha de código se quer. Bem, não sei nem por onde começar esta discussão, mas vou tentar colocar da melhor forma possível e depois deixo minha opinião e espero que vocês possam contribuir deixando a opinião de vocês. Aliás, para os menos avisados, NÃO EXISTE o Design Pattern TSF, na verdade estou chamando assim porque muitos, assim como eu, já brincaram de telefone sem fio quando criança e é exatamente isso que encontramos na maior parte das empresas quando se fala em desenvolvimento de software.

Você deve ter ficado meio confuso com isso não é? Como uma brincadeira de criança pode estar presente numa empresa que desenvolve software? “O Luciano ficou maluco? Telefone sem fio pra desenvolver sistemas? É, realmente ele pirou de vez!!”. O que posso dizer é, esse modelo de desenvolvimento existe e é amplamente utilizado!

Bom, antes de começarmos, gostaria de dizer os motivos que me levaram a escrever sobre esse assunto. O primeiro deles é porque estou estudando metodologias de desenvolvimento, o segundo é que percebi que terei mais uma vez que quebrar o paradigma para a construção de um software e o terceiro e último motivo é pelo simples prazer em compartilhar um pouco da minha experiência.

Para tentar explicar o que acabei de citar acima vamos ver um exemplo, qualquer coincidência é mera realidade (rsrs), para que vocês possam entender melhor o que estou dizendo.

Suponhamos que você seja o analista de uma fabrica de software e que seu mais novo projeto seja desenvolver um sistema para uma empresa de investimentos, uma corretora de valores.

Tudo começa quando você vai até o cliente e discute com ele tudo que ele precisa no novo software (Home Broker). A par do projeto e das necessidades do cliente, você irá discutir com o Analista de Negócios, pois ele, mais do que ninguém, possui o conhecimento de todo o funcionamento de um Home Broker. De posse de toda informação e de anotações feitas durante a discussão com o Analista de Negócio e com o cliente, você dá inicio ao processo de documentação, seguindo ou não algum padrão (isso vai de empresa para empresa, de analista para analista).

Findado este processo de documentação você irá validar estes documentos junto ao Analista de Negócio. Dada tal aprovação, o próximo passo é passar tudo para o Coordenador da equipe de desenvolvimento para que o mesmo possa repassar para os programadores e DBA´s suas tarefas para que os mesmos coloquem o desenvolvimento do projeto em prática.

A maioria dos projetos que trabalhei e que trabalho seguem essa linha de raciocínio, e isso não é exclusividade de uma ou outra empresa, esta forma de trabalho é geral, encontrada também em grandes empresas, posso citar dentre as quais trabalhei CEF e FGV.

Até ai tudo bem, não vimos nada demais só que como todo bom projeto, começam a surgir algumas dúvidas (digamos que sejam as regras de negócio, e olha que você documentou tudo heim!!) e logo um dos programadores irá até seu Coordenador tentar sanar a dúvida. Qual será a reação do Coordenador? Isso mesmo, ele irá até você (Analista de Sistemas) e, assim como ele, você irá até o Analista de Negócios tentar da melhor forma possível captar informações suficientes para sanar a dúvida do Coordenador que por sua vez irá repassar para o programador. Algo soa familiar a alguma brincadeira da sua infância? Alguma mera semelhança com o “Telefone sem Fio”? Não né!

E um dos problemas que vejo nessa forma de trabalho é quando as informações começam a sofrer distorção, ou seja, nem tudo é passado de forma correta para o pessoal de desenvolvimento gerando pequenas falhas no software e quando for enviado para a equipe de testes, muitos erros serão detectados fazendo com que o software volte para ser refeito gerando atrasos não planejados e consequentemente insatisfação por parte do cliente.

Os padrões de desenvolvimento de software são bons, mas como tudo que diz respeito à tecnologia, metodologias, conceitos e padrões, também precisam evoluir, e talvez um pouco mais de flexibilidade nestas comunicações seja uma forma de adicionar flexibilidade e minimizar os ruídos de comunicação.

SEO, ASP.Net e Paulovich.Data

André Paulovich — Tue, 03 Aug 2010 01:32:19 GMT

Uma boa dica para quem esta desenvolvendo websites em ASP.Net e pretende que seu projeto esteja bem posicionado nos mecanismos de busca é utilizar técnicas de Search Engine Optimization, ou simplesmente SEO.

Vou dar uma dica rápida de como você pode por exemplo, alterar um pouco a estrutura de navegação do seu projeto para ganhar muitas posições nos buscadores. Primeiramente precisamos criar um roteamento de requisições no servidor para eliminar URLs fracas semânticamente, como por exemplo: ~/noticias.aspx?codnoticia=12 e converter em algo como ~/noticias/muito-legal-programar-em-aspnet. Ou seja, ao inves da URL conter apenas o código da notícia nós podemos apresentar o título da matéria e ganhar mais “relevância” nos buscadores.

O meu vídeo na Copa Microsoft de Talentos foi sobre esse assunto, por isso vou deixar para vocês o link do mesmo, e não vou adentrar muito nesta etapa. ok?

UrlRouting com VS2010 - André Paulovich from André Paulovich on Vimeo.

Porém, mesmo depois que nós temos o roteamente pronto, nós ainda temos que dar um jeito de criar as URLs referentes ao conteúdo de acordo com os títulos. E é aí que entra a segunda parte da dica. Nós temos uma forma muito fácil de converter um texto cheio de caracteres especiais (que não podem ser usados em URLS), em um texto equivalente, que será compreendido tanto pelos buscadores como por nós que vamos lê-los.

Digamos que nossa notícia tenha o título: "É hoje o último dia da competição de pacman". Nós não podemos simplesmente colocar em caixa baixa o texto e eliminar os espaços, pois os acentos, cedilhas e etc continuariam avalhando as URLs. Por isso a melhor maneira é usando a tabela ASCII. São dois passos:

Precisamos de um array com os bytes do texto original (até aqui 8bits de informação por byte):
byte[] b = Encoding.GetEncoding(1251).GetBytes(name);
Depois, basta pegar o código ASCII de cada byte de texto:
string t = Encoding.ASCII.GetString(b);

Resumindo, quando você tem os caracteres áâàã, todos possuem o mesmo código ASCII e é essa a jogada. Falta agora apenas subistituir os espaços por um traço e nós podemos então criar uma função como esta:

 static public string GenarateAlias(string name)
 {   	
        byte[] b = Encoding.GetEncoding(1251).GetBytes(name); // 8 bit characters
        string t = Encoding.ASCII.GetString(b); // 7 bit characters  	
        return t.Trim().Replace(" ", "-").ToLower();
 }

Agora, para não ter que ficar chamando esta função o tempo todo, nós podemos inseri-la num evento do Paulovich.Data, onInserting e onUpdating, para que este “apelido” do título seja gerado sempre que o usuário salve uma nova notícia ou atualize uma existente. Se você ainda não conhece o ciclo de vida de uma classe Persist do Paulovich.Data veja neste link um exemplo rápido.

protected override void OnInserting(object sender, System.ComponentModel.CancelEventArgs e) 
{ 	
    Alias = GenarateAlias(Title); // O Alias é uma propriedade da classe Persist	
    base.OnInserting(sender, e); 
}   

protected override void OnUpdating(object sender, System.ComponentModel.CancelEventArgs e) 
{ 	
    Alias = GenarateAlias(Title); 	
    base.OnUpdating(sender, e); 
}

Pronto! Você já pode utilizar o Alias da notícia para retornar a notícia desejada.

A webAula quer o seu talento

André Paulovich — Thu, 29 Jul 2010 15:37:06 GMT

Como todos puderam perceber, nos últimos dias estivemos publicando algumas vagas aqui no blog, afinal a gente sempre fala em todos os nosso eventos: “Os grupos como o 100loop e DotNetRaptors são pontes entre a comunidade e o mercado”. Por isso nada mais natural que as empresas nos solicitarem para publicar algumas vagas aqui, normalmente a gente repassa essas vagas diretamente para algumas pessoas selecionando o perfil dos vagas e dos profissionais. Porém, estão aparecendo muitas vagas e por isso… vamos deixar as coisas seguirem o seu fluxo. A gente publica, quem interessar, corre atrás e batalha, ok?! Só queria ressaltar que não é nossa intenção fazer do 100loop uma agência de empregos… nossa intenção é continuar sempre com bons artigos técnicos como foco principal.

Quase todo mundo que posta aqui no 100loop trabalha na webAula, por isso se você está atrás de uma boa oportunidade de trabalho e “de quebra” trabalhar próximo de profissionais diferenciados e envolvidos com a comunidade técnica, essa pode ser a sua chance. Venha trabalhar conosco. A webAula S/A é pioneira e líder no mercado de e-learning brasileiro. Com unidades em Belo Horizonte, Brasília, São Paulo e Atlanta/EUA, e no momento oferece diversas oportunidades de trabalho, em vários ramos de atuação. Em especial separei três vagas que estão de acordo com o nosso público. Segura aí…

Analista de Sistemas .Net - Belo Horizonte (1 vaga)
O analista .NET tem todas as atribuições do programador .NET e também deve ter condições de analisar e criar diagramas de classes e entidade-relacionamento, utilizando as boas práticas do projeto orientado por objeto. Também deve contribuir junto ao gerente na conceituação dos produtos emitindo opiniões e validando as informações.

Programador .Net - Belo Horizonte (1 vaga)
O programador .NET desenvolve aplicativos baseados na tecnologia .NET. Deve ser capaz de entender especificações documentadas e solicitações verbais. Deve desenvolver sistemas inteiros ou partes deles, codificar com habilidade em client side (JavaScript) e server side (C#). Deve também realizar testes básicos nas implementações com o objetivo de minimizar o retrabalho e ter boa qualidade nas produções. O programador deve também ter condições de elaborar sentenças SQL complexas que envolvam múltiplas tabelas e construir stored procedures.

Programador ASP - Belo Horizonte (1 vaga)
O analista ASP tem todas as atribuições do programador ASP e também deve ter condições de analisar e criar diagramas de classes e entidade-relacionamento, utilizando as boas práticas do projeto orientado por objeto. Também deve contribuir junto ao gerente na conceituação dos produtos emitindo opiniões e validando as informações.

Para ver a lista completa de oportunidades acesse: http://www.webaula.com.br/pt/trabalhe-conosco se você quizer se candidatar, basta mandar seu currículo para lucia.mendes@webaula.com.br.

Grande abraço a todos,
A gente se vê por aqui… (nenhuma referência ao slogan da rede globo, viu!)

Atualizando para ASP.NET 4

Ivan Paulovich — Tue, 27 Jul 2010 13:17:31 GMT

Voltei de uma viagem de férias ontem. E voltei animado para atualizar o blog para ASP.NET 4, então se nas próximas horas ocorrem algumas loucuras por aqui não se desesperem.

HTTPHandlers

André Castro — Wed, 14 Jul 2010 14:51:14 GMT

Fala Filhotes…

Hoje vou mostrar um “esqueminha” que apesar de não ser novidade (nenhuma) é bastante interessante do ASP.NET, mas primeiro vamos a uma pequena explicação sobre o funcionamento de paginas web.

Imagino que muitos de vocês devem ter aprendido isso na faculdade mas deixa eu fazer um resumão:

Muitos anos atrás quando a internet estava engatinhando, os servidores web usavam apenas arquivos simples como .html, mas a medida que o tempo passou as necessidades também aumentaram. Os programadores precisavam estender a capacidade dos servidores web de alguma forma. Então a Microsoft criou o ISAPI ( Internet Server API) e graças a isso conseguimos extender varias funcionalidades do IIS ( e outros servidores web que são compatíveis com o ISAPI ). Beleza!!! Mas e ai? Cumé qui esse trem funciona?

Bom filhote, é ate bem simples… Veja bem, o ISAPI consiste basicamente de dois componentes: Extensões e Filtros:

Extensões:

As extensões ISAPI são as aplicações que realmente rodam no IIS, e possuem acesso a todas as funcionalidades do IIS. As extensões podem ser implementadas usando DLLs.

As extensões ISAPI devem ser chamada para serem executadas, por exemplo, para chamar a extensão ISAPI usuariocadastro.dll você deve chamar a seguinte URL enviando também os valores que ela precisa via query string:

http://www.siteteste.com.br/usuariocadastro.dll?nome=Andre&idade=22&sexo=M&url=100loop.com.br/

Filtros:

Um filtro ISAPI é um … bom… filtro, entre o servidor web e o cliente. Ao contrario das extensões ISAPI que o usuário tem que chamar a URL para escuta-las, toda requisição para o servidor passa no filtro ISAPI e o próprio servidor passa a requisição para o filtro responsável. Um filtro ISAPI pode criar um log das requisições ou mesmo tratar / modificar alguma informação.

Requisições do ASP.NET

As requisições do ASP.NET são feitas de forma linear, a requisição é passada por todos os módulos, aonde cada um pode realizar qualquer tipo de ação sobre ela. Depois de passar por todos os módulos ela irá para um (apenas um) HTTP handler. O handler processa a requisição e o resultado será novamente enviado a todos os módulos.

Certo! Agora que entendemos um pouco mais sobre o funcionamento do ISAPI e ASP.NET, vamos ao que interessa!

HTTPHandlers

Então, como vimos um HTTPHandler é um código que executa quando uma requisição para um recurso especifico é feita pelo server. Você consegue interagir com a requisição e até enviar um novo retorno ao browser. Para criar um HTTP Handler, você precisa criar uma classe que implemente a interface IHttpHandler ( para um Handler síncrono) ou IHttpAsyncHandler ( para um handler assíncrono ) ou ate mesmo qualquer classe que implemente IHttpHandlerFactory. Você deve implementar a propriedade IsReusable e o método ProcessRequest para se usar o IHttpHandler e os métodos BeginProcessRequest e EndProcessRequest para o IHttpAsyncHandler . A propriedade IsReusable mostra quando o objeto IHttpHandlerFactory ( O objeto que chama o Handler correto ) vai pôr o Handler numa pool para o reutilizar depois ( aumentando a performance ) ou se vai criar uma nova instancia sempre que precisar dele de novo. O método ProcessRequest é o método chave, o que faz o processamento da requisição.

Beleza! Parece ser muito, muito complicado, mas na verdade é bem simples. Vamos ao exemplo!

Nesse exemplo criaremos um thumbnail, que por padrão SEMPRE encolherá a imagem, quer dizer, se o usuário acessar a imagem diretamente ( 100loop.com.br/imagem.jpg ) ele também à verá encolhida. Então, como eu vejo ela no tamanho original ou aumento o tamanho do thumbnail? bom, é só mandar o tamanho dela via Query String. Estranho? Mais ou menos, dê uma olhada no código:

Primeiro a nossa classe que herda do handler:

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.SessionState;
using System.Configuration;
using System.Web.UI;
using System.Drawing;
using System.IO;
using System.Drawing.Imaging;


namespace HttpHandlers
{
    public class HandlerLogin : IHttpHandler
    {
        /// 
        /// Propriedade necessaria! 
        /// 
        public bool IsReusable
        {
            get
            {
                return false;
            }
        }

        /// 
        /// Metodo que cria um thumbnail de uma imagem, calculando o tamanho para não perder as proporções
        /// 
        ///  Local da imagem 
        ///  Nova largura da imagem 
        ///  Nova Altura da imagem 
           public Bitmap CreateThumbnail(string path, int parWidth, int parHeight)
        {
            // Nosso Bitmap de retorno
            Bitmap bmpOutput = null;

            try
            {
                // Nova bitmap para pegar o arquivo e suas medidas
                Bitmap bitTemp = new Bitmap(path);

                ImageFormat loFormat = bitTemp.RawFormat;
                
                // Variavel para manter a proporção
                decimal ratio;

                int newWidth = 0;

                int newHeight = 0;

                // Se a Imagem for menor que o Thumbnail então retorna a imagem
                if (bitTemp.Width < parWidth && bitTemp.Height < parHeight)

                    return bitTemp;
                // Pega a proporção dividindo a largura pela altura
                ratio = (decimal)bitTemp.Width / bitTemp.Height;

                newHeight = parHeight;
                newWidth = parWidth;
                
                // Checa qual lado é maior para manter a proporção baseado nesse lado.
                if (parHeight > parWidth)
                {               
                    decimal lnTemp = newHeight * ratio;

                    newWidth = (int)lnTemp;
                }
                else
                {
                    decimal lnTemp = newWidth / ratio;

                    newHeight = (int)lnTemp;
                }                              

                
                // Cria o bitmap com as nossas medidas
                bmpOutput = new Bitmap(newWidth, newHeight);

                // Criamos um objeto do tipo Graphics para podermos "desenhar" a imagem no nosso output
                Graphics newGraphic = Graphics.FromImage(bmpOutput);
                
                // Setamos o InterpolationMode para HighQualityBicubic para não perdemos (ou perdemos menos ) qualidade
                // na imagem na hora de encolhê-la. Claro, o tamanho do arquivo fica um pouco maior.
                newGraphic.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

                // transformamos areas transparentes dos gifs em branco.
                newGraphic.FillRectangle(Brushes.White, 0, 0, newWidth, newHeight);

                // Desenhamos a nossa imagem ( q esta no temp ) com os novos tamanhos no output
                newGraphic.DrawImage(bitTemp, 0, 0, newWidth, newHeight);
                
                // Fechamos o temp
                bitTemp.Dispose();

            }

            catch
            {

                return null;

            }


            // Retornamos a nossa imagem
            return bmpOutput;

        }

        /// 
        /// Metodo principal que irá executar quando uma imagem for chamada (método necessario!)
        /// 
        /// 
        public void ProcessRequest(HttpContext context)
        {
            try
            {

                int width;
                int height;

                //Verifica se o usuario passou a largura da figura
                if (context.Request.QueryString["width"] != null)
                {
                    width = int.Parse(context.Request.QueryString["width"]);
                }
                else
                {
                    width = 100;
                }
                //Verifica se o usuario passou a altura da figura
                if (context.Request.QueryString["height"] != null)
                {
                    height = int.Parse(context.Request.QueryString["height"]);
                }
                else
                {
                    height = 100;
                }                          

                // Pega o caminho do arquivo fisico
                string path = context.Request.PhysicalPath;
                // Pega a extensão para determinar o tipo da imagem
                string contentType = path.Substring(path.LastIndexOf(".") + 1);

                ImageFormat newFormat;

                // Altera o formato dependendo do tipo do arquivo
                switch (contentType)
                {
                    case "gif":
                        newFormat = ImageFormat.Gif;
                        break;
                    case "jpg":
                        newFormat = ImageFormat.Jpeg;
                        contentType = "jpeg";
                        break;
                    case "png":
                        newFormat = ImageFormat.Png;
                        break;
                    default:
                        newFormat = ImageFormat.Jpeg;
                        break;
                }
             
                // Arquivo Bitmap com o thumbnail ja criado
                Bitmap newThumb = CreateThumbnail(path, width, height);

                // Seta o ContentType ( image/jpeg, image/gif ... )
                context.Response.ContentType = "image/" + contentType;

                // Salva a imagem no Output que retornara ao usuario.
                newThumb.Save(context.Response.OutputStream, newFormat);
                newThumb.Dispose();
                
            }
            catch (Exception ex)
            {
                throw;
            }
          

        }
    }
}

Então blz! criamos a classe! Mas para podermos habilitar esse handler precisamos adicionar uma tag a mais no web.config, dentro de <configuration><system.web> adicione essa tag:

Mas o que é essa configuração? uma breve explicação:

Type: Nome da Classe / DLL separado por virgula se for mais de um.
Verb: A lista de verbos que seu componente utiliza, separados por virgula e entre aspas ex: (“GET,POST,HEAD”)
Path: A URL inteira ou parte dela em que o seu Handler ira ser invocado. Ex: *.aspx ( o seu handler executara em todas paginas .aspx ) ou default.aspx (apenas nessa pagina )

Obs: Isso só funciona a partir do IIS 6.0. Antes disso tinha que adicionar o Handler direto no IIS.

Então é isso ai, agora é só criar uma pagina com uma imagem como eu fiz aqui, lembrando que a proporção é realizada automaticamente:

Você pode adicionar o método no onclick chamando a imagem com o tamanho maior.

Isso foi só uma demonstração do uso de httpHandlers, há vários outro jeitos de melhorar esse nosso Thumbnail, depende da criatividade/necessidade de cada um. Uma outra coisa bacana seria fazer marca d’água em suas imagens (só em imagens em alguma pasta especifica por exemplo ).

Bom Filhotes, qualquer duvida me avisem! Ate mais!

Fontes:

http://www.15seconds.com/issue/020417.htm
http://msdn.microsoft.com/pt-br/library/7d6sws33%28VS.85%29.aspx

Como usar Windows Live Writer Beta e SubText

Ivan Paulovich — Fri, 09 Jul 2010 12:07:06 GMT

Não há dúvidas que a ferramenta mais confortável para criar posts é o Windows Live Writer. E agora temos uma nova versão cheia de novidades e facilidades disponível para download.

O passao a passo abaixo irá mostrar como é simples configurar o Windows Live Writer para postar seus textos no SubText.

Como configurar

Abrar o Windows Live Writer Beta e clique em Add Blog Account.

Selecione Other blog service.

Digite o endereço do seu blog, no caso do 100loop nós usamos blogs agregados então digito o endereço do autor do blog e clique em Next.

Aguarde o Windows Live Writer baixar as configurações do seu blog como tema, categorias e outras preferências. Em seguida clique em Next.

Digite um nome para o seu blog e clique em Finish.

Pronto. Você tem agora o conforto de um editor de textos totalmente integrado aos posts do seu blog. Você pode editar os seus posts e clicar em Publish que o texto estará no ar.