Enviado por
André Castro
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
Enviado por
Ivan Paulovich
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.
Enviado por
Luciano Lima
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!
Enviado por
Ivan Paulovich
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.
Enviado por
Ivan Paulovich
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.
Enviado por
Luciano Lima
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!
Enviado por
André Castro
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!
Enviado por
Luciano Lima
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!!
Enviado por
Ivan Paulovich
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.
Enviado por
Darlesson
Original em inglês no endereço http://www.darlesson.com/jquery/querystring/
Este código foi criado para facilitar pegar valores de query strings usando o jQuery. Ele pode retornar o valor de uma query string, uma coleção de query strings, a quantidade, selecionar a query string pelo índice e não diferenciar maiúsculas e minúsculas.
Instalação
- Faça o download dos arquivos
- Se ainda não tiver a referência do jQuery no seu HTML inclua como no exemplo abaixo
- Escolha um dos arquivos do jQuery QueryString para ser referido no seu HTML. A primeira opção pode ser a mais adequada se você não deseja modificar o código.
// Se você ainda não tem o arquivo do jQuery informado no seu
// HTML, insira o código abaixo
<script type="text/javascript" src="javascript/jquery-1.4.2.min.js"></script>
// Insira o código a seguir após o código do jQuery se você
// deseja a versão compacta de $.QueryString ou...
<script type="text/javascript" src="source/querystring-0.9.0-min.js"></script>
// ... insira o código abaixo se preferir a versão para
// desenvolvedores
<script type="text/javascript" src="source/querystring-0.9.0.js"></script>
Como Usar
Se não informado, $.QueryString irá procurar a query string da barra de endereço do browser. Para informar uma URL diferente, verifique os parâmetros de options.
// Retorna null se não existe nenhuma query string
$.QueryString();
// Retorna o total de query strings
$.QueryString().size;
// Retorna null se a query string solicitada não existir
// ou o valor daquery string se existir
$.QueryString( //string );
// Informa o total de query strings de mesmo nome
$.QueryString( //string ).length;
// Retorna o valor de uma query string de uma URL informada, escolhe
// o índicee diferencia ou não maiúsculas e minúsculas
$.QueryString( //string, { // options
href : // URL string,
index : // number,
isCaseSensitive : boolean
});
// Pega o valor de uma query string como um objeto
$.QueryString().objectName;
Os parâmetros de options e seus valores aceitos são:
href (string)(opcional) URL com ou sem query strings onde as query strings serão procuradas. Padrão: window.location
index (number)(opcional) Retorna o valor de uma query string em uma coleção de query strings de mesmo nome. Padrão: null
isCaseSensitive (boolean)(opcional) Decide se a query string procurada deve ter as letras maiúsculas e minúsculas deferenciadas. Padrão: true
Exemplos
Visite www.darlesson.com/jquery/querystring/.
Suporte
Este código é gratuito sob as licensas MIT e GPL. Mas se você acha que ele foi de grande ajuda economizando o seu tempo, por favor me dê suporte financeiramente através de uma doação ou adicione o link do meu site (http://darlesson.com/) no seu pra que possa continuar compartilhando, criando e melhorando meus códigos.
Para informar bugs, por favor envie comentários ou sugestões pela minha página de contato.
Enviado por
André Castro
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!
Enviado por
Luciano Lima
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!!
Enviado por
Ivan Paulovich
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.
Enviado por
André Castro
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.
Enviado por
João Paulo
Pessoal, como dito no post anterior vamos as dicas sobre Page Rank. Antes de mais nada é importante dizer algumas coisinhas:
- Page Rank, apesar de ser a técnica mais relevante para o rankeamento do Google, não é a única estratégia que se deve usar. Ela é uma das muitas ferramentas usadas para melhorar seu posicionamento.
- As dicas tem a mesma importância e ajudarão a alcançar o resultado desejado se usadas em conjunto.
- Caso precise de alguma dica ou esclarecimento sobre PR, fique a vontade para me perguntar.
Antes uma pergunta: “Você deseja que sua página de ‘Contato’ seja a primeira no resultado do Google?”
Provavelmente não. Pense nas dicas abaixo como uma forma de colocar as páginas ou a página mais relevante do seu site em primeiro lugar no resultado de busca.
Dicas
1) Durante as reuniões de planejamento do seu projeto, leve em consideração a linkagem interna do seu site.
- Provavelmente seu projeto terá áreas que você deseja maior número de visitas e que seu público alvo considere mais relevante. Imagine que a página que “fala” diretamente do seu serviço/produto é a mais importante para você, tenha muitos links para essa página, com isso ela será considerada mais relevante e poderá ser o resultado da busca do usuário.
- Tente diminuir ao máximo o número de links que apontam para páginas menos relevantes, caso contrário você terá um concorrência desnecessário dentro do seu site.
- Retire links que não são realmente necessários, eles podem causar perda de força para o PR. Melhor ter uma quantidade menor de links com muita relevância e semântica que vários links apontando para páginas erradas.
2) Caso você tenha um link importante dentro do seu site e seu único desejo é criar uma âncora para a página sem distribuir PR por ele, utilize o atributo “nofollow” dentro da tag <a> ( rel=”nofollow” ), dessa maneira você manterá links importantes para navegação sem arriscar o Page Rank.
3) Sempre que algum conteúdo for gerado dentro do seu site/blog busque fazer referências que favoreçam a transferência de PR positivo para suas páginas. Você tem um blog de notícias, fale dos grandes blogs de notícias. Assim, se você contribuir para aumentar o PR de sites fortes eles podem contribuir com você.
Como funciona a transferência de Page Rank dentro do seu site:
É isso galera, espero que gostem!
Dúvidas estou a disposição,
Grande abraço a todos!
Enviado por
Ivan Paulovich
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.
Enviado por
Ivan Paulovich
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.
Enviado por
João Paulo
Fala pessoal, andei pensando numa forma legal de falar sobre SEO e cheguei a conclusão que partir para as técnicas poderia ser meio chato, então vou tentar esclarecer cada ferramenta separadamente e depois postar um “Como usá-la”. Acredito que assim a galera vai saber exatamente o que o seu site precisa e não usar SEO igual um robô sem entender o porque. Vamos começar pelo Page Rank que é bem simples de explicar e entender também.
Page Rank é uma forma de classificação que o Google utiliza buscando determinar a importância do seu site, ou de uma página, para si mesmo (o próprio Google) e para a internet. Essa classificação pode ser realizada através de uma escala logarítmica que varia entre 0 e 10 e que determina quão relevante cada página do seu site é.
Esse cálculo é feito encima da quantidade de links que suas páginas recebem. Ao contrário do que a maioria das pessoas pensam, ter SOMENTE um número grande de links na sua página não significa necessariamente ser pontuado com Page Rank 10. Esse grau de relevância será maior se, esses links forem semânticamente relacionados entre as páginas.
Para ilustrar como funciona:
Você tem uma banda amadora desconhecida e 10 bandas amadoras desconhecidas falam muito bem de você, para o público que curte música isso não será muito relevante, por que essas 10 bandas não tem “moral” para falar sobre música boa. Imagine se o Metallica ou o U2 falem bem de você, nem precisa dizer o resultado, certo?
Funciona dessa forma, além de suas páginas terem um bom número de links, esses link devem ser relevantes para a internet, seria o mesmo que dizer: É ótimo quando páginas com Page Rank 10 estão apontadas para o meu site.
Além disso, é muito importante que sites com assuntos relacionados ao seu conteúdo apontem para o seu site.
Para ilustrar como funciona:
Você tem uma banda de rock amadora e desconhecida, as 10 maiores agências de modelo do mundo falam muito bem de você, para o público que curte rock isso não significa nada e você terá muita dificuldade para ficar famoso.
Cuidado: Os sites em que o conteúdo é considerado suspeito ou apresentem algum perigo ao usuário pode diminuir o seu PR.
Vídeo explicando o Page Rank
Enfim, não basta somente sites PR 10 falarem de você, mas eles devem necessariamente estar ligados ao seu conteúdo para que a pontuação seja máxima.
Aguardem o “Como usar o Page Rank”
Valeu, abraço a todos!
Enviado por
André Paulovich
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.
Enviado por
André Paulovich
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.