Arquivo

Textos com Etiquetas ‘.NET’

Melhores posts do ano de 2009

8 de janeiro de 2010

Vídeos da PDC 2009 estão disponíveis

29 de novembro de 2009

Nos dias 17 a 19 de novembro, aconteceu em Los Angeles a PDC 2009, Professional Developers Conference, evento anual organizado pela Microsoft para desenvolvedores focados nas plataformas de desenvolvimento da empresa.

A organização do evento disponibilizou mais de 200 vídeos (e alguns slides) das apresentações para download. Para baixar os vídeos acesse esse endereço.

.NET, Eventos , , , , ,

[Tradução] Qual é a diferença entre os operadores “as” e “cast”?

29 de outubro de 2009

Muitas pessoas lhe dirão que a diferença entre “(Alpha) bravo” e “bravo as Alpha” é que o primeiro lança uma exceção se a conversão falhar, enquanto que o segundo retorna null. De qualquer forma isso é correto, e isso é a diferença mais óbvia, mas não é a única diferença. Há armadilhas para se tomar cuidado aqui.

Primeiro, desde que o resultado do operador “as” pode ser null, o tipo do resultado precisa ser um dos que aceitam um valor nulo: um tipo referência ou tipo valor nullable. Você não pode fazer “as int”, isso não faz sentido. Se o argumento não é um int, então qual valor de retorno deveria ser? O tipo da expressão “as” é sempre um tipo nomeado, então ele precisa ser um tipo que pode receber null.

Segundo, o operador cast, como eu discuti antes, é uma besta estranha. Ele significa duas coisas contraditórias: “verifique para ver se o objeto realmente é desse tipo, lance uma exceção se não for” e “esse objeto não é do tipo informado; encontre um valor equivalente que pertença ao tipo informado”. O segundo significado do operador cast não é compartilhado pelo operador “as”. Se você diz

short s = (short)123;
int? i = s as int?;

então você está sem sorte. O operador “as” não fará conversões “representação-substituição” de short para int nullable como o operador cast faria. Similarmente, se você tem uma classe Alpha e uma outra classe não relacionada Bravo, com uma conversão de Bravo para Alpha, então “(Alpha) bravo” será convertido, mas “bravo as Alpha” não. O operador “as” apenas considera conversões de referência, boxing e unboxing.

E finalmente, é claro que o uso dos dois operadores são superficialmente similares, mas semanticamente completamente diferentes. O cast comunica para o leitor “Eu estou certo que esta conversão é legal e eu concordo em receber uma exceção se eu estiver errado”. O operador “as” comunica “Eu não sei se esta conversão é legal ou não; nós vamos tentar e ver o que acontece”.

Esse texto é uma tradução do post original que Eric Lippert, engenheiro de software da Microsoft, publicou no seu blog Fabulous Adventures In Coding. A versão original você pode ler aqui.

Observação: Essa é minha primeira experiência em tradução de artigos técnicos. Seu comentário expressando sua opinião a respeito é muito bem vinda.

.NET , , , , , ,

Serialização de objetos em JSON com .NET

23 de outubro de 2009

Serializar e deserializar instâncias de objetos no formato JSON com .NET acaba sendo muito simples.

Esse é o Jason, não JSON.

Vamos utilizar como exemplo a classe abaixo:

public class SomeFakeClass
{
    public int ID { get; set; }

    public string Text { get; set; }

    public decimal Value { get; set; }
}

E criamos uma instância dela:

SomeFakeClass fake = new SomeFakeClass
{
    ID = 123,
    Text = "I am a sample text.",
    Value = 150.85M
};

Então queremos serializar a variável fake em JSON para obter o seguinte resultado:
{"ID":123,"Text":"I am a sample text.","Value":150.85}

A classe DataContractJsonSerializer torna essa tarefa muito fácil. Basta escrever os dados serializados para um Stream usando o método WriteObject e depois recuperar uma string a partir desse Stream:

MemoryStream stream = new MemoryStream();

DataContractJsonSerializer serializer;
serializer = new DataContractJsonSerializer(typeof(SomeFakeClass));
serializer.WriteObject(stream, fake);

string json = return Encoding.Default.GetString(stream.ToArray());

Para fazer o inverso, transformar dados em JSON para um objeto, usamos o método ReadObject passando o Stream que possui os dados serializados:

string json = "{"ID":123,"Text":"I am a sample text.","Value":150.85}";

MemoryStream stream = new MemoryStream(json);

DataContractJsonSerializer serializer;
serializer = new DataContractJsonSerializer(typeof(SomeFakeClass));

SomeFakeClass fake = (SomeFakeClass)serializer.ReadObject(stream);

Um detalhe importante é que a partir do .NET Framework 3.5 Service Pack 1 não há mais a necessidade de decorar a classe que queremos serializar com os atributos DataContract e DataMember, como o exemplo abaixo:

[DataContract]
public class SomeFakeClass
{
    [DataMember]
    public int ID { get; set; }

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

    [DataMember]
    public decimal Value { get; set; }
}

Isso somente se faz necessário se quisermos ter uma controle maior do que será serializado, como por exemplo, serializar uma propriedade com um nome diferente. Na classe abaixo, a propriedade Text é configurada para ser serializada com o nome Message:

[DataContract]
public class SomeFakeClass
{
    [DataMember]
    public int ID { get; set; }

    [DataMember(Name = "Message")]
    public string Text { get; set; }

    [DataMember]
    public decimal Value { get; set; }
}

Os dados serializados em JSON podem ser algo como:
{"ID":123,"Message":"I am a sample text.","Value":150.85}

Para usar a classe DataContractJsonSerializer, que está no namespace System.Runtime.Serialization.Json, é necessário adicionar referências para dois assemblies no seu projeto:

  • System.Runtime.Serialization
  • System.ServiceModel.Web

Agora que já sabemos como serializar e deserializar em JSON, podemos criar um utilitário que faz esse trabalho. O exemplo abaixo utiliza Extensions Methods combinados com Generics:

public static class JsonSerializerExtensions
{
    public static string ToJson<T>(this T obj)
    {
        MemoryStream stream;

        using (stream = new MemoryStream())
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            serializer.WriteObject(stream, obj);
        }

        return Encoding.Default.GetString(stream.ToArray());
    }

    public static T FromJson<T>(this string json)
    {
        T obj;

        using (MemoryStream stream = new MemoryStream(Encoding.Default.GetBytes(json)))
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            obj = (T)serializer.ReadObject(stream);
        }

        return obj;
    }
}

E um exemplo de sua utilização:

SomeFakeClass fake = new SomeFakeClass
{
    ID = 123,
    Text = "I am a sample text.",
    Value = 150.85M
};

string fakeJson = fake.ToJson();

SomeFakeClass otherFake = fakeJson.FromJson<SomeFakeClass>();

.
O código-fonte desse utilitário você pode baixar aqui.

.NET, Livros , , ,

MSDN Magazine: revista grátis sobre .NET

5 de setembro de 2009

Desde que comecei a desenvolver em .NET sempre gostei de ler alguma revista a respeito. Atualmente assino a revista Mundo .NET, mas antigamente eu assinava a .NET Magazine, que na época era MSDN Magazine Brasil. Quando ela deixou de ser MSDN Magazine Brasil para virar .NET Magazine, houve uma grande mudança editoral e na minha opinião o seu conteúdo deixou a desejar.

Por conta disso, procurei pela MSDN Magazine original e, para minha surpresa e felicidade, descobri que sua versão online é totalmente gratuita. A qualidade e diversidade dos artigos são muita boas e entre os autores estão nomes importantes como Dino EspositoJeremy MillerJohn Papa.

A versão online também está disponível em português, mas recomendo verozmente que você fique longe dela, pois a mesma é feita através de um tradutor automático. As primeiras edições disponibilizadas em português eram traduzidas por humanos, então até pode ser que você encontre algum artigo antigo em português que não contenha nenhum absurdo de tradução.

Na verdade, agora estou realmente pensando em não mais assinar a Mundo .NET e acompanhar somente a MSDN Magazine, pois de algumas edições para cá o conteúdo da Mundo .NET tem me decepcionado.

Em resumo, a MSDN Magazine é uma revista americana, mantida pela própria Microsoft, de publicação mensal, com versão impressa paga e versão online grátis.

Você pode acessá-la utilizando o endereço abaixo:
http://msdn.microsoft.com/en-us/magazine/default.aspx

.NET , , , ,

Prometric oferece até 25% de desconto em exames Microsoft

5 de setembro de 2009

A Prometric está com uma promoção onde você pode obter 15%, 20% ou 25% de desconto ao se registrar para um exame de certificação Microsoft.

Para participar da promoção “Take control of your career”, basta acessar a página da promoção, escolher um dos exames com desconto e se registrar no mesmo. Entre as opções, há exames de certificação em .NET, SQL Server e Windows.

A promoção é válida para exames agendados até 31 de dezembro de 2009.

Para mais informações e participar da promoção, acesse o link abaixo:
http://www.prometric.com/microsoft/careeroffer.htm

.NET , , , , , , , ,

Cheeseburgers, Decorators e Mocks

29 de julho de 2009

Em São Paulo, eu sempre comi cheeseburgers feitos com pão, hamburguer e queijo. Mas quando eu fui para Itararé, cidade do interior do estado de São Paulo, descobri que eles também colocavam milho no sanduíche.

Para exemplificar, vamos imaginar que o cheeseburger de Ilhéus-BA, venha com molho de pimenta. Só para constar, eu nunca fui para Ilhéus, apesar de ser a cidade natal de meu pai. Então na verdade não tenho a mínima idéia de como seja o cheeseburger de lá.

Imagem original de MarketFare Foods, Inc.

Imagem original de MarketFare Foods, Inc.

Vamos transportar esses três tipos de cheeseburgers para objetos e fazer alguns testes com eles. Usarei como plataforma .NET, linguagem C#, a ferramenta de testes unitários que vem com o Visual Studio 2008 e o Rhino Mocks como framework de criação de mocks.

Leia mais…

.NET, Arquitetura , , , , , , , , , , , , ,

.NET Architects Day 2009

13 de junho de 2009

No próximo dia 27 de junho vai rolar o primeiro evento do grupo de discussão sobre arquitetura de software .NET Architects.

Eu infelizmente não vou, pois estarei em outro evento. Mas Luciano Coelho e Rodrigo Ortiz, que trabalham comigo, irão e poderão nos contar tudo que aconteceu.

Algo interessante é que exatamente todos os assuntos que serão abordados, estaremos utilizando em um novo projeto que irá iniciar no segundo semestre.

Veja o conteúdo das palestras:

Programando com prazer com Domain Driven Design (DDD)
Giovanni Bassi
O Domain Driven Design é uma nova abordagem para desenvolvimento de software. Mas não é tão nova assim. Ela reune melhores práticas de OO e traz uma nova visão a velhos conceitos. Entenda nesta palestra a proposta do DDD, e porque ele pode mudar sua maneira de programar.

Utilizando Injeção de Dependência com Unity (Enterprise Library)
Leandro Daniel
Nessa palestra veremos o padrão de Injeção de Dependência como uma alternativa técnica na construção de aplicações plugáveis, onde se deseja manter a flexibilidade para troca de componentes com menor impacto de manutenção, maior reusabilidade e facilidade na aplicação de testes.

ASP.NET MVC: tome seu HTML de volta
Victor Cavalcante
Nessa palestra veremos o que é o ASP.NET MVC e o que ele não é, como ele funciona, diferenças entre ASP.NET MVC e Web Forms, extensibilidade, testabilidade, criação de templates com T4 e jQuery. A intenção desta palestra é dar informações suficientes para que o arquiteto decida utilizar ou não ASP.NET MVC.

ORM - Sendo preguiçoso com NHibernate
Juliano Oliveira
Nessa palestra você verá os principais pontos que fazem dos frameworks de ORM e do NHibernate ferramentas tão importantes nos projetos, desmistificar seus maiores mitos, os principais recursos, ferramentas de análise (NHProof) e verá também como ser produtivo com o NHibernate.

Testes: garantindo que seu código faz o que você quer
Mauricio Aniche
Entenda porque testes automatizados de software são importantes e quais as vantagens que ele traz para a equipe de desenvolvimento. Veja também na prática que criar testes automatizados é simples, rápido e realmente útil.

O valor da inscrição é de R$ 50,00 e o evento terá aproximadamente 9 horas de duração.
Mais informações você pode ter diretamente na página do evento.

.NET, Arquitetura, Eventos, TDD , , , , , , , , , , , ,

Não use nulo no retorno de coleções

9 de junho de 2009

Quando você tiver um método em que o retorno é algum tipo de coleção, ou seja, qualquer classe que implemente IEnumerable ou uma de suas interfaces filhas, nunca retorne null.

Quando a lógica do seu método não tiver elementos para serem colocados na coleção de retorno, você deve retornar uma lista vazia, com zero elementos. Essa boa prática vai facilitar a vida do código que irá consumir seu método.

Vamos ver um exemplo de um método que retorne uma coleção:

public class BookService
{
    public IList<Book> FindBooksByTitle(string startsWith)
    {
        //Alguma lógica que não encontra nenhum livro.
        return null;

        //Código restante.
    }
}

E o código que consome o método FindBooksByTitle:

BookService bs = new BookService();

foreach (var book in bs.FindBooksByTitle(&amp;amp;quot;The history&amp;amp;quot;))
{
    //Faz alguma coisa com a variável book.
}

Do jeito que está, se nenhum livro for encontrado de acordo com o critério passado, o valor retornado será null. Consequentemente, na linha 3 do código consumidor será gerada uma exceção do tipo NullReferenceException, pois tentará iterar através do foreach em uma variável nula.

Como resolvemos isso? Ah, basta colocar uma verificação se o retorno do método é nulo:

BookService bs = new BookService();
IList<Book> books = bs.FindBooksByTitle("The history");

if (books != null)
{
    foreach (var book in books)
    {
        //Faz alguma coisa com a variável book.
    }
}

Errado! O código que consome o método não pode ficar responsável por fazer esse tratamento. Senão, todo código que consumir o método FindBooksByTitle precisará fazer essa verificação de retorno nulo antes de iterar na coleção. Essa responsabilidade tem de ficar dentro da classe BookService e não fora dela.

Consertando o exemplo para retornar uma lista vazia:

public class BookService
{
    public IList<Book> FindBooksByTitle(string startsWith)
    {
        //Alguma lógica que não encontra nenhum livro.
        return new List<Book>();

        //Código restante.
    }
}

Agora o código consumidor pode iterar sem erros, mesmo que não seja encontrado nenhum livro:

BookService bs = new BookService();

foreach (var book in bs.FindBooksByTitle("The history"))
{
    //Faz alguma coisa com a variável book.
}

.NET , , ,

Como medir o uso da CPU utilizando Performance Counters

4 de maio de 2009

Na última semana no trabalho, dois desenvolvedores estavam procurando uma forma de recuperar a porcentagem de uso da CPU utilizando .NET. Eles encontraram uma solução utilizando Win32_Processor de WMI e classes do namesapce System.Management, escrevendo algo mais ou menos assim:

ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_Processor");
ManagementObjectSearcher searcher = new ManagementObjectSearcher(query);

int load = 0;
int cpus = 0;

foreach (ManagementObject mo in searcher.Get())
{
    load += Convert.ToInt32(mo["LoadPercentage"]);
    numCpus++;
}

decimal cpuUsage = load / cpus;

Uma maneira mais fácil de fazer isso, e que atende ao propósito de medir recursos utilizados da máquina, é utilizar Performance Counters. Classes como PerformanceCounter e PerformanceCounterCategory, que são encontradas no namespace System.Diagnostics, lhe dão acesso não somente a informações do uso do processador, mas também informações sobre cachê de sistema, disco físico, memória, threads, entre outros.

O exemplo abaixo mostra como criar uma instância da classe PerformanceCounter para recuperar a porcentagem do uso da CPU naquele instante:

PerformanceCounter cpuCounter = new PerformanceCounter
{
    CategoryName = "Processor",
    CounterName = "% Processor Time",
    InstanceName = "_Total"
};

float cpuUsage = cpuCounter.NextValue();

Note que na propriedade CategoryName é informado “Processor”, a categoria referente ao processador da máquina, e na propriedade CounterName, o contador que se refere à porcentagem do tempo de processamento. Em algumas categorias de Performance Counter é necessário especificar o nome da instância do contador, através da propriedade InstanceName, como é o caso da categoria “Processor” do exemplo acima, onde está sendo utilizado a instância “_Total”. Na minha máquina, para a categoria “Processor”, também estão disponíveis as instâncias “0″ e “1″, que se referem aos dois núcleos do meu AMD Athlon™ 64 X2 Dual Core Processor 6000+.

Na categoria “Memory” não é necessário especificar o nome da instância. Veja abaixo o exemplo de como obter a quantidade de memória disponível:

PerformanceCounter ramCounter = new PerformanceCounter
{
    CategoryName = "Memory",
    CounterName = "Available MBytes"
};

float availableRam = ramCounter.NextValue();

Para recuperar todas as categorias disponíveis para medição, use o método GetCategories da classe PerformanceCounterCategory:

PerformanceCounterCategory[] categories;
categories = PerformanceCounterCategory.GetCategories();

A partir de uma categoria, você pode recuperar todas os nomes de contadores. Por exemplo, o código abaixo:

var category = new PerformanceCounterCategory("System");

foreach (PerformanceCounter counter in category.GetCounters())
{
    Console.WriteLine(counter.CounterName);
}

Gera a seguinte saída:

File Read Operations/sec
File Write Operations/sec
File Control Operations/sec
File Read Bytes/sec
File Write Bytes/sec
File Control Bytes/sec
Context Switches/sec
System Calls/sec
File Data Operations/sec
System Up Time
Processor Queue Length
Processes
Threads
Alignment Fixups/sec
Exception Dispatches/sec
Floating Emulations/sec
% Registry Quota In Use

Eu fiz duas aplicações console de exemplo utilizando Performance Counters:

  • Uma exibe a porcentagem de uso da CPU e a quantidade de MB de memória disponíveis, atualizando as informações a cada um segundo;
  • A outra lista todos os nomes de instâncias e contadores de algumas categorias.

Você pode baixar essas duas aplicações aqui.

.NET , ,