Postado por Jonathan Allen, traduzido por Felipe V. Rigo em 04 Mai 2009 11:44 AM

No PDC 2008, a Microsoft prometeu paridade entre as linguagens Visual Basic e C#. O que isso significa para o .NET 4 foi enumerado durante o keynote Lang.NET(marca de 18 minutos). Brevemente, isso é o que você pode esperar pra ver.

Novas funcionalidades para ambas as linguagens

• Interoperabilidade com Dynamic Languages (linguagens dinâmicas)
• Coo/contra-variação
• publicação de PIA não necessária

Novo para o VB 10, já disponível no C#

• Auto-implementação de propriedades
• Inicializadores de Coleções
• Declarações lambda

Novo para o C# 4, já disponível para o VB

• Parâmetros Nominados/Opcionais
• Suporte a Latebinding
• Omissão do “ref” em chamadas COM

Infelizmente, duas funcionalidades chaves não fazem parte da lista. O C# 4 não irá embarcar Literais XML e o VB não terá iteradores.

Sem mencionar algumas funcionalidades menores, mas assim mesmo necessárias como permitir estruturas em parâmetros opcionais. A inabilidade de declarar um opcional, inteiro anulável em uma função faz com que fazer um mapeamento 1-para-1 com stored procedures impossível. Isso foi demonstrado para o VB entre sessões no PDC.

Fonte: InfoQ

Essa é uma das respostas do Márcio Tierno no grupo UML-FATEC, sobre a eterna discussão sobre qual a melhor plataforma de desenvolvimento: Java ou .NET.

Sei que esse assunto de quem é melhor Java x .NET é quase como discutir sobre religião. Mas o problema sobre produtividade no desenvolvimento de software é uma questão de foco, ou melhor, o problema não é tecnológico e sim estratégico.

“Um pouco de números para tentar dar um pouco de prumo a essa discussão:

1 – 80% dos negócios do mundo rodam em cima de programas COBOL. Nem Java nem .NET vão decidir o futuro da humanidade, portanto.

2 – Nunca vi um sistema que não pudesse ser implementado em qualquer linguagem que seja. Portanto, a discussão Java x .NET não se decide na esfera técnica.

3 – Produtividade – não é criando grids para acesso direto a tabelas que se mede produtividade, mas sim no tempo total que leva para uma idéia sair da cabeça do usuário de negócios até se transformar em um sistema rodando no ambiente de produção, testado, aprovado e homologado. Numa “competição” Java x .NET, é certo que ambas as tecnologias chegariam empatadas “na margem de erro” caso se considerasse todo o ciclo de vida de um sistema.

4- Ainda em produtividade, só de 15% a 20% do tempo é gasto efetivamente em implementação. O grosso do esforço é gasto em levantamento de requisitos e testes.

Por falar em produtividade, só 30% do tempo do programador é gasto em desenvolvimento de fato, em média. O resto é perdido em debugging ou reescrevendo requisitos que foram mal-entendidos (e mal-explicados, por conseguinte). Pare e pense na sua rotina diária e veja se vc discorda desses números.

Assim, 20% X 30% = 60% do tempo total de um projeto em desenvolvimento REAL. Supondo que uma das duas tecnologias fosse 50% MAIS PRODUTIVA do que a outra (e nenhuma delas o é), o impacto final seria de 3% sobre o tempo total do projeto. Quase indetectável.

Assim, o desafio proposto perde a validade em si. Até porque ninguém vai sair “convertido” de um evento desses. Agora, um desafio de ponta a ponta, num prazo de algumas semanas, por exemplo, esse sim teria valia. Mas já não seria mais um desafio Java x .NET, mas, talvez, um desafio MDA x AMD (tipo Together) x Agile (S. Ambler), por exemplo.

4 – Decisões estratégicas – Há uns 20 anos, mais ou menos , o Natural/ADABAS ganhou um grande mercado do COBOL, porque era muuuito mais produtivo e fácil de mexer. Hoje quem tem Natural/ADABAS quer morrer, porque a Software AG está cobrando os tubos (zilhões de dólares) pela renovação das licenças e a tecnologia é “imigrável”. Paralelo com .NET, proprietário como Natural/ADABAS. Erro estratégico.

Outro exemplo: há 30 anos, C prometia ser o que Java promete hoje. Se alguém algum dia teve um sistema de negócios escrito em C, então deve ter uma boa história de migração urgente para contar. Paralelo com Java, “assembleísta” como C. Outro erro estratégico.

Então, amigos, tecnologicamente falando, Java e .NET se equivalem.

Não consigo imaginar um sistema corporativo (que é o que interessa, afinal) que possa ser feito em um, mas não no outro. Ou que saia muito mais rápido em um do que no outro.

Portanto, o cerne da questão é estratégico, não tecnológico.

E todos os xiitas são gentilmente deixados de lado nessas discussões.

De minha parte, entre Java e .NET, fico com arquitetura de software, MDA e Governança de TI.

Na guerra entre as partes, prefiro vender a munição.

Márcio Tierno (mtierno.rm): é atualmente responsável por toda a divisão de testes funcionais da Inmetrics. Atua na área há 16 anos, tendo trabalhado em empresas como Compuware do Brasil, IBM, Rational Software, BCP Telecomunicações, entre outras. Cursou Ciência da Computação na Unicamp, é certificado ITIL Foundations e Rational Requirements Mngt. Marcio já prestou consultoria e ministrou dezenas de treinamentos em Ger. de Projetos, Requisitos e demais disciplinas de desenvolvimento para empresas como Serpro, Xerox, BankBoston, Banco Itaú, Banco Votorantim, Cargill, Porto Seguro e outras de grande porte, no Brasil e no exterior.

Por: André Dourado

Existem duas formas de desenvolver relatórios master-detail utilizando o Reportviewer. A primeira opção é utilizar subreports. A segunda, que oferece melhor performance, é utilizar aninhamento de regiões.

Neste tutorial será mostrado como utilizar o Reportviewer para criação de relatórios master-detail através do uso de subreports.

Fontes: RelatorioTeste.zip (57K)

1.Crie um projeto chamado RelatorioTeste;

2.Crie para este exemplo, classes de manipulação dos dados. Por serem apenas classes para efeito didático, não se preocupe com acessos a banco. São classes apenas para prover dados para o relatório. Para este exemplo definiremos classes que representam Clientes e os Contatos desses Clientes.

Cliente.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    public class Cliente
    {
        public Int32 clienteId { get; set; }
        public String clienteNome { get; set; }
 
        public Cliente()
        {
        }
    }
}


ClienteDAO.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    class ClienteDAO
    {
        public List getAll()
        {
            List listaCliente = new List();
 
            Cliente cliente1 = new Cliente();
            cliente1.clienteId = 1;
            cliente1.clienteNome = "Empresa Xyz S.A.";
            listaCliente.Add(cliente1);
 
            Cliente cliente2 = new Cliente();
            cliente2.clienteId = 2;
            cliente2.clienteNome = "Empresa Klz Ltda.";
            listaCliente.Add(cliente2);
 
            return listaCliente;
        }
    }
}


Contato.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    class Contato
    {
        public Int32 contatoId { get; set; }
        public String contatoNome { get; set; }
        public Int32 clienteId { get; set; }
 
        public Contato()
        {
        }
    }
}


ContatoDAO.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RelatorioTeste
{
    class ContatoDAO
    {
        public List getByCodigo(Int32 clienteId)
        {
            List listaContato = new List();
 
            switch (clienteId)
            {
                case 1:
                    Contato contato1 = new Contato();
                    contato1.contatoId = 1;
                    contato1.contatoNome = "Fulano de Tal da Empresa 1";
                    contato1.clienteId = 1;
                    listaContato.Add(contato1);
 
                    Contato contato2 = new Contato();
                    contato2.contatoId = 2;
                    contato2.contatoNome = "Ciclano de Tal da Empresa 1";
                    contato2.clienteId = 1;
                    listaContato.Add(contato2);
 
                    Contato contato3 = new Contato();
                    contato3.contatoId = 3;
                    contato3.contatoNome = "Antitese de Tal da Empresa 1";
                    contato3.clienteId = 1;
                    listaContato.Add(contato3);
 
                    break;
 
                case 2:
                    Contato contato4 = new Contato();
                    contato4.contatoId = 4;
                    contato4.contatoNome = "Fulano de Tal da Empresa 2";
                    contato4.clienteId = 2;
                    listaContato.Add(contato4);
 
                    Contato contato5 = new Contato();
                    contato5.contatoId = 5;
                    contato5.contatoNome = "Ciclano de Tal da Empresa 2";
                    contato5.clienteId = 2;
                    listaContato.Add(contato5);
 
                    Contato contato6 = new Contato();
                    contato6.contatoId = 6;
                    contato6.contatoNome = "Antitese de Tal da Empresa 2";
                    contato6.clienteId = 2;
                    listaContato.Add(contato6);
 
                    Contato contato7 = new Contato();
                    contato7.contatoId = 7;
                    contato7.contatoNome = "Prognostico de Tal da Empresa 2";
                    contato7.clienteId = 2;
                    listaContato.Add(contato7);
 
                    break;
            }
 
            return listaContato;
        }
    }
}


3.Adicione os DataSources ao projeto

1. Utilizando o menu do VS: “Data > Add New Data Source…”;
2. Escolha o tipo “Object” e clique em Next;
3. Selecione na árvore de objetos do projeto o objeto “Cliente” e clique em “Finish”;
4. Repita o passo 3, selecionando agora o objeto “Contato”;

4.Crie o relatório “master”:

1. Na janela “Solution Explorer” clique com o botão da direita do mouse sobre o projeto “RelatorioTeste”;
2. Selecione as opções “Add” e depois “New Item…”. Selecione o template “Report” e clique sobre o botão “Add”. O nome desse primeiro report deverá receber o nome “Report1.rdlc”;
3. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report1.rdlc”;
4. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “List” e arraste até o “Report1”;
5. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “Textbox” e arraste para o interior do “List”;
6. Na janela “Data Sources” selecione a propriedade “clienteId” do datasource “Cliente” e arraste para o interior do TextBox criado no passo 4;
7. Repita os passos 4 e 5 para a propriedade “clienteNome”;
8. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “Subreport” e arraste para o interior do “List”;

5.Crie o relatório “detail”:

1. Na janela “Solution Explorer” clique com o botão da direita do mouse sobre o projeto “RelatorioTeste”. Selecione as opções “Add” e depois “New Item…”. Selecione o template “Report” e clique sobre o botão “Add”. O nome desse primeiro report deverá receber o nome “Report2.rdlc”;
2. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report2.rdlc”;
3. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “List” e arraste até o “Report2”;
4. Na janela “ToolBox”, na divisão “Reporting Items” clique sobre o componente “Textbox” e arraste para o interior do “List”;
5. Na janela “Data Sources” selecione a propriedade “contatoId” do datasource “Contato” e arraste para o interior do TextBox criado no passo 4;
6. Repita os passos 4 e 5 para a propriedade “contatoNome”;

6.Utilize o formulário “Form1” para armazenar o componente ReportViewer:

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Form1”;
2. Na janela “ToolBox”, na divisão “Reporting” clique sobre o componente “MicrosoftReportViewer” e arraste até o “Form1”
3. Selecione qual o relatório será exibido pelo ReportViewer. Selecione “RelatorioTeste.Report1″, conforme a tela a seguir:

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report2.rdlc”;
2. No menu do VS selecione a opção: “Report > Report Parameters…”;
3. Na tela de definição de Parâmetros clique sobre o botão “Add” e defina o parâmetro “parCodigoCliente”, conforme a tela a seguir. Ao final clique no botão “Ok”;

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Report1.rdlc”;
2. Clique com o botão da direita do mouse sobre o componente “Subreport”. Selecione a opção “Properties”. Na aba “General” selecione no campo “Subreport:” o report “Report2″;

1. Selecione a aba “Parameters”;
2. Selecione nos campos as opções de forma que fiquem como a tela a seguir:

1. Na janela “Solution Explorer” dê duplo clique sobre o objeto “Form1.cs”;
2. No formulário dê duplo clique sobre o título do Formulário, ou selecione nos eventos do form o evento “Load”;
3. Insira no evento “Form1_Load” o seguinte código:

private void Form1_Load(object sender, EventArgs e)
{
    reportViewer1.LocalReport.SubreportProcessing += new SubreportProcessingEventHandler(LocalReport_SubreportProcessing);
 
    ClienteDAO clienteDAO = new ClienteDAO();
    List listaCliente = new List();
    listaCliente = clienteDAO.getAll();
 
    ClienteBindingSource.DataSource = listaCliente;
 
    reportViewer1.RefreshReport();
}
 
void LocalReport_SubreportProcessing(object sender, SubreportProcessingEventArgs e)
{
    int codigoCliente = Int32.Parse(e.Parameters["parCodigoCliente"].Values[0]);
 
    ContatoDAO contatoDAO = new ContatoDAO();
    List listaContato = new List();
    listaContato = contatoDAO.getByCodigo(codigoCliente);
 
    e.DataSources.Add(new ReportDataSource("RelatorioTeste_Contato", listaContato));
}
 
Na linha: e.DataSources.Add(new ReportDataSource(“RelatorioTeste_Contato”, listaContato)), “RelatorioTeste_Contato” corresponde ao namespace (RelatorioTeste) onde o objeto (Contato) está armazenado. Sendo que o objeto (Contato), que pode ser um POCO/VO/TO/DTO (não defendendo nenhuma pattern em especial, apenas para efeito didático), contém as definições das propriedades utilizadas no subreport.

11.Execute o projeto. O resultado obtido deve ser semelhante a esse:

Estive nas últimas semanas, envolvido com a emissão de Nota Fiscal Eletrônica. Depois de todos os consumos de webservices, certificados digitais, chegamos ao problema da impressão da DANFE, mais especificamente em relação ao código de barras padrão Code128C.

Muitos componentes são oferecidos a um preço de “oportunidade”. Depois de muito procurar, achei alguns links que acho que podem interessar.

Gerador de Código de Barras com fontes em C#: http://www.codeproject.com/KB/GDI-plus/GenCode128.aspx

True Type Fonts para Code128: http://www.fpress.com/revista/Num9905/fuentes.zip

Espero que ajude a alguém.

Vídeo da palestra sobre DDD apresentada pelo Giovanni Bassi do grupo “.NET Architects” no terceiro encontro do grupo em 13/12/2008.

Após a apresentação houve um debate com todos os presentes por cerca de uma hora.

Fonte: ITea – TI e Chá?

Postado por Abel Avram, traduzido por Felipe Rodrigues em 17 Fev 2009 06:00 AM

O ASP.NET MVC está usando o T4 (Text Template Transformation Toolkit) para gerar código por trás das cenas quando um Controler ou uma View é adicionada ao projeto. O T4 é um gerador de texto totalmente customizado baseado em templates.

Uma das funcionalidades do ASP.NET MVC anunciada por Scott Cuthrie é usar o T4 para geração de código. O código é gerado pela engine do T4 a partir de um template de texto. Isso quer dizer que pode-se criar ou editar o template tendo controle completo sobre o código resultante.

Um template T4 parece muito com qualquer outro Web Form, combinando blocos de texto simples com lógica de controle. Abhishek Mishra deu um exemplo detalhado de como editar um.

Não há suporte inteligente para edição de templates T4 no Visual Studio, mas a Clarius Consulting oferece um T4 Editor Community Edition integrado com o VS e fornecendo syntax highlighting. Ele também oferece uma versão Pro que oferece verdadeiro suporte intellisense e edição do gerador de código T4 suportando hosts T4 customizados(WSSF, ASP.NET MVC), integração com o Server Explorer, Drag & Drop de arquivos XML e XSD, API de DB amigável para inspecionar metadados e outros.

O T4 pode ser usado para automatizar a geração de arquivos de texto de qualquer tipo e propósito. Scott Hanselman deu tal exemplo usando um template para gerar código LINQ to SQL. Scott recomenda o uso do T4 para qualquer tarefa repetitiva de geração de texto, não apenas relacionadas ao .NET: “Se você está fazendo algo duas vezes ou mais, manualmente, em sua empresa, gere isso.”

A InfoQ internacional oferece uma introdução técnica ao T4 incluindo links para a documentação no MSDN e posts úteis.

Fonte: InfoQ

Até agora o engine de geração de código do Mono era baseado em uma árvore de representação intermediária (IR) do código. A versão 2.2 possue uma nova engine baseada em uma IR linear, que traz melhorias significativas de velocidade e tamanho de código.

A IR baseada em árvore anterior tornava "difícil melhorar a geração de código e extender o engine JIT de maneira significativa", de acordo com Miguel de Icaza. O novo IR linear ajuda a "melhorar a visibilidade do uso do alocador de registro, assim ele pode fazer melhores escolhas quando produzindo código".

O trabalho na IR linear começou no final de 2005. O trabalho evoluiu mas o time do Mono não queria incluir a nova engine no 2.0 por causa da quatidade de trabalho envolvido. Agora, que a versão 2.2 foi liberada, o Mono tem uma nova engine.

O efeito mais importante da mudança é mostrado pelos resultados de benchmark:

Velocidade: O engine beneficiará código computacionalmente intensivo, normalmente entre 10% e 30% de aumento de performance, with alguns casos chegando a 50% mais rápido.

Tamanho do código: a nova engine gera código menor, tipicamente 12% a 20% menor.

Aqueles interessados nos detalhes da nova engine podem encontrá-los no website do Mono. Os Release Notes para a versão 2.2 mencionam as seguintes melhorias: performance aumentada, suporte para compilação antecipada, suporte para monitoramente através de PerformanceCounters, anexar código ao vivo, suporte a SIMD e outros.

Fonte: InfoQ

Scott Guthrie anunciou hoje que o ASP.NET MVC 1.0 Release Candidate, está disponível para download. Este release é o último release público, antes do release final 1.0 planejado para Fevereiro.

Está disponível no Codeplex desde 16/07/2008, o quarto preview do ASP.Net MVC. Com novidades de todos os tipos, como novos filter interceptors, output cache, endereçamento de erro, autorização, AJAX e mais um monte de novidades.

Como os caras da Microsoft não dormem, já tem comentário de boa parte do time que o está desenvolvendo, começando pelo ótimo Scott Guthrie (que escreveu ainda antes do lançamento), Scott Hanselman (esse não dorme mesmo), Phil Haack, e Rob Conery. O mais completo é o do ScottGu.

Phil Haack no MVC Preview 4 no “The Continuum Show” do Channel 9 do MSDN.

O conteúdo completo da entrevista está disponível no Channel 9

Fonte: .NET Unplugged

Mas afinal o que é então o ASP.NET MVC ?
O ASP.NET MVC é uma implementação da arquitetura MVC para o ASP.NET em um framework com o objetivo de criar aplicações WEB no padrão MVC e fornecer uma alternativa ao modelo WebForm do ASP.NET disponível até então. O framework ASP.NET MVC fornece um ambiente robusto e leve que esta integrado aos recursos do ASP.NET como master pages e membership sendo definido no namespace System.Web.Mvc e apresenta os seguintes componentes:

• Models – Os objetos Model (modelo) são as partes da aplicação que implementam a lógica o domínio de dados da aplicação e retornam e armazenam o estado do modelo em um banco de dados.
• Views – As views (visões) são os componentes que exibem a interface do usuário e em geral é criada a partir do modelo de dados.
• Controllers – Controllers (controladores) são os componentes que tratam com a interação do usuário, trabalham com o modelo e selecionam uma visão para ser exibida; Em uma aplicação MVC uma view somente exibe informação , o controller trata e retorna a entrada do usuário e a interação.

Como eu posso usar o ASP.NET MVC?
Para usar o ASP.NET MVC você precisa instalar a ASP.NET MVC Preview 3 (May 2008) release (faça o download aqui : Microsoft ASP.NET MVC page) ; você vai precisar ter a .NET Framework 3.5 instalada e o Visual Studio 2008 ( a versão RTM não suporta o MVC).

Quando usar o ASP.NET MVC?
Como tudo na vida é uma questão de bom senso, e você deverá pesar bem os prós e contras antes de decidir se vai implementar o padrão MVC através do ASP.NET MVC na sua aplicação Web ou continuar a usar o modelo WebForm (sim ele vai continuar a existir). Lembre-se que o framework MVC não veio substituir o modelo Web Forms ele veio ser uma opção a mais a ser considerada.

Quais as vantagens e desvantagens envolvidas no ASP .NET MVC?

Vantagens :

1. Como o modelo MVC gerencia múltiplos visualizadores usando o mesmo modelo é fácil manter , testar e atualizar sistemas múltiplos;
2. É muito simples incluir novos clientes apenas incluindo seus visualizadores e controles;
3. Torna a aplicação escalável;
4. É possível ter desenvolvimento em paralelo para o modelo , visualizador e controle pois são independentes;
5. É mais fácil gerenciar a complexidade da aplicação dividindo-a em modelo, visualizador e controlador (MVC);

Desvantagens:

1. Requer uma quantidade maior de tempo para analisar e modelar o sistema;
2. Requer pessoal com conhecimento especializado;
3. Não é aconselhável para pequenas aplicações;

Existe somente o Framework MVC da Microsoft?
Não , o projeto Castle disponibiliza o Framework web MVC MonoRail (Inspirado no Ruby on Rails) que pode ser baixado gratuitamente no site : http://www.castleproject.org/monorail/index.html

O MonoRail é um projeto anterior ao MVC da Microsoft e neste momento possui mais documentação e exemplos, vale a pena conferir.

Fonte: Macoratti.net – ASP.NET – MVC – Model-View-Controller – Introdução