Depois do Complexo do Alemão, esse é o próximo morro na lista...

Web Designers vs Web Developers

Web Designers vs Web Developers is brought to you by Wix.com
Use creative design to make a Free Website
You are most welcome to share this infographic with your audience.

Microsoft Launches Visual Studio Async CTP

Vale a pena conferir essa matéria: clique aqui.

Reinvented Human-Computer Interaction

10/GUI from C. Miller on Vimeo.

eBook Tip

Free eBook do Velho Petz!

Programming Windows Phone 7

by Charles Petzold          

JQuery e Ajax Demos & Tips

O 9Lessons tem ótimos tutoriais, demos e dicas de utilização de JQuery e Ajax... Vale a pena conferir!

Introdução a expressões Lambda em C#

Para entender o que são expressões lambda, devemos voltar um pouco no tempo. Vamos voltar ao tempo do .NET 1.0 (C# 1.0) e iniciar com o conceito de delegates. O conceito de delegates não é tão novo como o advento do .NET. Ele veio antes, em C por exemplo, era chamado de "ponteiro para função"  (expressão que diz mais sobre o que um delegate realmente faz). Um delegate, como o "ponteiro para função", guarda uma  referência a uma função (ou método - o que você preferir) e permite que chamemos essa função quando precisarmos.

Em .NET, os "ponteiros para função" foram chamados de delegates e adicionou-se segurança de tipo a ele,  o que significa que, em um delegate, devemos especificar exatamente o tipo do resultado que a função apontada retorna e os argumentos (e os tipos de seus argumentos) que essa função espera receber.  Podemos, então, usar o delegate para apontar para um método que tenha a assinatura especificada (se tentarmos apontar para uma função  com assinatura diferente da especificada, receberemos erro no momento da compilação - Ótimo!)

Podemos,  então, passar esse delegate pra frente como se fosse uma variável:

internal sealed class Program

{

     //Definição do Delegate

    public delegate void MyCoolDelegate(string arg);

     static void Main(string[] args)

    {

                  //criando um delegate e apontando-o para o método "PrintToConsole"

                  MyCoolDelegate myCool = new MyCoolDelegate(PrintToConsole);

                  //chamando o delegate

                  myCool(“Test”);

    }

    public static void PrintToConsole(string value)

    {

                  Console.WriteLine(value);

     }

}

Um delegate é apenas uma referência a um método que você pode usar como uma variável. Podemos passa-lo a um método e chamá-lo onde for necessário. Esse é um conceito poderoso pois com eles, podemos tratar funções e métodos como dados, como fazemos com as variáveis. Funções se tornaram "cidadãos de primeira classe". (outro uso interessante dos delegates é para fazer chamadas assíncronas a métodos, facilitando o modo de fazer multithreading... vou passar por isso outro dia).

                Vamos avançar um pouco e parar no tempo quando o .NET 2.0 e o C# 2.0 foram lançados. Para o C# 2.0, o time de desenvolvimento dessa ferramenta adicionou uma coisa muito legal e útil: Métodos Anônimos (ou anonymous delegates). A diferença entre os métodos anônimos e os delegates tradicionais (como o eram no .NET 1.0) é que não precisamos mais definir um método em algum outro lugar do código e apontá-lo como o delegate para que ele funcione. Com os métodos anônimos, definimos o método a chamar no mesmo instante em que criamos o delegate e o compilador de C# tomará os cuidados necessários. O compilador C# criará o método para nós e o converterá em algo que pareça exatamente como no .NET 1.0.
Vamos comparar o funcionamento de um delegate tradicional com um método anônimo:

     // o modo tradicional

       internal sealed class Program

       {

           static void Main(string[] args)

           {

                  //criando uma lista com alguns dados

                  List<string> list = new List<string>();

                  list.Add(“value1");

                  list.Add(“value2");

                  //procura na lista. Precisamos especificar um método

                  //aqui que conterá a lógica para encontrar os dados que precisamos

                  string result = list.Find(new Predicate<string>(FindInList));

        }

         //Método utilizado para procurar o dado na lista

             static bool FindInList(string value)

             {

                  return (value == “value2");

             }

    }

     //agora, utilizando método anônimo

     internal sealed class Program

     {

          static void Main(string[] args)

         {

                  //criando uma lista com alguns dados

                  List<string> list = new List<string>();

                  list.Add(“value1");

                  list.Add(“value2");

                  //procurando na lista utilizando um método anônimo

                  string result = list.Find(delegate(string value){ return (value == “value2"); });

          }

    }

Podemos ver claramente a diferença aqui. Com os métodos anônimos, não precisamos criar outro método e um delegate que aponta para esse método. Dizemos apenas que queremos um delegate aqui e especificamos o corpo do método a ser chamado. É muito mais conveniente utilizar um método anônimo ao invés do modo com delegate tradicional. O definição do código a utilizar fica junto a sua utilização. Outra característica introduzida com os métodos anônimos é a possibilidade de usar variáveis definidas fora do método anônimo:

    static void Main(string[] args)

    {

                  //criando uma lista com alguns dados

                  List<string> list = new List<string>();

                  list.Add(“value1");

                  list.Add(“value2");

                  string toFind = “value2";

                  

                   //utilizando variável externa ao método anônimo (toFind)

                  string result = list.Find(delegate(string value) { return (value == toFind); });

    }

                  Neste exemplo vemos o uso da variável "toFinde" dentro corpo do método do delegate embora tenhamos o definido fora dele. Neste caso, o compilador C# não somente cria o método para nós mas toda uma classe (que contém o método) onde o valor que usaremos no corpo do delegate é passado como um membro dessa classe.

Nos dias de hoje, no C#3.0 (e no .NET 3.5) temos as expressões Lambda que são o próximo passo na "evolução do delegate". Agora, o compilador faz sumir o "delegate(...) {...}" (economizando um monte de digitação). Uma expressão lambda sempre consiste de duas partes (esquerda e direita) separadas por um "=>". A parte à esquerda do "=>" contém uma lista de argumentos (não necessariamente tipados pois os tipos podem ser automáticamente indicados pelo compilador). O lado direito contém o corpo do método. Uma expressão lambda, ainda, sempre espera um valor de retorno (por isso não podemos omitir a palavra-chave "return"):

    static void Main(string[] args)

    {

                  // criando uma lista com alguns dados

                  List<string> list = new List<string>();

                  list.Add(“value1");

                  list.Add(“value2");

                  string toFind = “value2";

                  //utilizando uma expressão lambda

                  string result = list.Find(value => toFind == value);

    }

Para resumir: expressões lambda são delegates (ou "ponteiros para função" com segurança de tipo). Elas só têm essa aparência devido a alguns pressupostos adotados, como o fato das expressões lambda serem funções e deverem sempre retornar algo e que os tipos podem ser automáticamente informados pelo compilador. Um efeito colateral bom das expressões lambda é que elas, no mínimo, nos economizam muita digitação e muito tempo de desenvolvimento (além de organizar muito mais nossos códigos).

(baseado no artigo:  http://msdn.microsoft.com/en-us/library/bb397687(VS.90).aspx)

Captcha Simples (anti-robot)

Exemplo simples de implementação de um Captcha (anti-robot)...


Captcha Sample

Instruções no ReadMe.txt

[]s

Poder Total no Windows 7

Crie, no desktop, uma pasta com o nome:

FullPower.{ED7BA470-8E54-465E-825C-99712043E01C}

Ops: Não faço idéia se funciona em outros SOs.

[]s

ASP.NET Menu no Chrome e Safari

Ainda sobre o componente de Menu do ASP.NET, pra ele renderizar corretamente
no Chrome e no Safari, coloque no Page_Load (da MasterPage, por exemplo), a
seguinte verificação:
   
    if (Request.UserAgent.IndexOf("AppleWebKit") > 0)
       Request.Browser.Adapters.Clear();

[]s

ASP.NET Menu no IE8

Para contornar a incompatibilidade do controle ASP.NET Menu com o IE8, crie um "style"
com um ".ZIndexParaMenu {z-index: 1;}" e utilize-o como CssClass do DynamicMenuStyle do Menu.
(ou instale nos servidores (se puder!) a correção: http://support.microsoft.com/kb/962351/en-us)

[]s

Feliz 2010!!!

Visual Studio 2010 and .NET Framework 4 Beta Period Extended

            Microsoft has listened to user feedback concerning Visual Studio 2010 Beta 2 performance issues and bugs and decided to extend the Beta period. The new Visual Studio version introduces numerous changes, including many that focus on multicore programming. A new checkpoint release, a Release Candidate would be publicly available during February 2010.

S. Somasegar, Senior Vice President, Microsoft Developer Division made it very clear in his blog post "Visual Studio 2010 and .NET Framework 4 Beta period extended". The launch of Visual Studio 2010 and .NET Framework 4 won't be in March, it would a few weeks later than expected in order to react to the new feedback obtained with the forthcoming Release Candidate.

From Dr. Dobb’s

A Microsoft ouviu o feedback dos usuários sobre questões de desempenho e bugs sobre o Visual Studio 2010 Beta 2 e decidiu prorrogar o período de avaliação Beta do produto. A nova versão do Visual Studio indroduz várias alterações incluindo muitas que focam a programação multicore. Uma nova versão "checkpoint" Release Candidate seria disponibilizada ao público em fevereiro de 2010.

S. Somasegar, Vice Presidente Senior da Divisão de desenvolvimento de produtos da Microsoft deixou isso muito claro em seu blog no post "Visual Studio 2010 e .NET Framework 4 Beta period extended". O lançamento o Visual Studio 2010 e .NET Framework 4 não será em março, seria algumas semanas depois do esperado para que se possa analisar o novo feedback obtido com a próxima versão Release Candidate.

Operador Null-Coalescing ?? (C#)

          Estava lendo "CLR via C#" de Jeffrey Richter noite passada quando me deparei com o operador Null-Coalescing. Sabia sobre sua existência, mas nunca soube realmente para que ele fosse utilizado.

          Muitas vezes, ao codificar, você precisa atribuir uma variável A a uma B apenas se a variável A não for nula. Se A for nula, você quer que B receba outro valor (talvez um default).

          Usando o operador condicional do C#, seu código se pareceria com algo assim:

               string fileName = tempFileName != null ? tempFileName : "Untitled";

          Se tempFileName não for nulo, fileName receberá o valor de tempFileName, caso contrário, fileName receberá o valor "Untitled".

          Utilizando o operador Null-Coalescing, seu código poderia ser abreviado para algo assim:

               string fileName = tempFileName ?? "Untitled";

          A lógica é a mesma: Se tempFileName for nulo, fileName recebe seu valor, caso contrário, recebe "Untitled".

          O operador Null-Coalescing é muito útil com os tipos anuláveis, em particular ao converter esses tipos para seu tipo de origem:

               int? count = null;

                         int amount = count ?? default(int);

          Uma vez que count é nulo, amount receberá o valor default para um tipo inteiro, ou seja, zero.

          Os operadores condicionais e o Null-Coalescing não são os operadores mais auto explicativos que existem, mesmo assim eu amo programar em C#!

Tradução (livre e porca) de "C# Conditional Operator ( ?: ) and Null-Coalescing Operator ( ?? )"

de David Hayden

          Links interessantes:

               ?? Operator (C# Reference)

               The C# ?? null coalescing operator (and using it with LINQ)

[]s

Luis Fernando

WMI Code Creator

Para aqueles que querem desenvolver em C#, VB.NET ou scripts que utilizem o WMI, uma sugestão que lhes poupará horas de pesquisas: Baixem o WMICodeCreator da Microsoft (gratuito). Ele fornecerá explicação sobre toda interface necessária para o desenvolvimento e exemplos de utilização.

Interessante verificar o fonte do aplicativo que acompanha o download...

http://www.microsoft.com/downloads/details.aspx?FamilyID=2cc30a64-ea15-4661-8da4-55bbc145c30e&displaylang=en

Overview

The WMI Code Creator tool generates code that uses WMI to obtain management information or perform management tasks. You can use the tool to learn how to manage computers using WMI scripting and WMI .NET. The tool generates code that runs on the local computer, a remote computer, or a group of remote computers based on your selection from the Target Computer menu on the tool. You can also execute the generated code directly from the tool.

The tool is meant to help IT Professionals quickly create management scripts and to help developers learn WMI scripting and WMI .NET. The tool helps take the complexity out of writing code that uses WMI and helps developers and IT Professionals understand how powerful and useful WMI can be for managing computers.

Using the tool, you can query for management information such as the name and version of an operating system, how much free disk space is on a hard drive, or the state of a service. You can also use the tool to execute a method from a WMI class to perform a management task. For example, you can create code that executes the Create method of the Win32_Process class to create a new process such as Notepad or another executable. The tool also allows you to generate code to receive event notifications using WMI. For example, you can select to receive an event every time a process is started or stopped, or when a computer shuts down.

The tool also allows you to browse through the available WMI namespaces and classes on the local computer to find their descriptions, properties, methods, and qualifiers.

The code that creates the tool is also included in the download. The tool was created using WMI .NET, and the code for the tool can help developers understand how WMI .NET is used to create applications and manage information. Be sure to read the end-user license agreement that is included in the download.

[]s

Luis Fernando