Ola pessoal acabei de gravar um vídeo para mostrar um protótipo que desenvolvi.

A idéia é controlar um carrinho de controle remoto pelo controle no Nitendo WII, usando um microcontrolador PIC16F628A.

Segue o esquema:

E para se interessar, o anexo contem o projeto no VisualStudio, o código-fonte do PIC (tanto o arquivo .asm e .hex) o esquema eletrônico em .jpg e para o Proteus ISIS. Se estiver faltando algo me avise. Controle-Carrinho-RC-MagoDigital.zip (349,53 kb)

Acho que todo mundo, quando está aprendendo algoritmos, sempre faz um exercício para calcular a seqüência do Fibonacci. Um algoritmo padrão em C# seria:

public int Fibonacci(int x)
{
if (x <= 1)
return 1;
return Fibonacci(x - 1) + Fibonacci(x - 2);
}

Mas como seria um algoritmo usando os recursos do C# 3.0? No blog do Scott Hanselman's, achei nesse post, implementações em várias linguagens, veja como fica no C# 3.0:

Func fib = null;
fib = n => n > 1 ? fib(n - 1) + fib(n - 2) : n;
for (int c = 0; c < 10; c++)
{
    Console.WriteLine(String.Format("{0}= {1}", c, fib(c)));
}

O operador yield é muito pouco usado, mas apos conhecê-lo hoje e fiquei impressionado porque nunca vi nada parecido.

Ele é usado para retornar uma instancia de um IEnumerable, vou explica melhor em forma de exemplo.

Vamos supor que você queira  apenas retornar os números pares de um vetor, você faria +/- assim:

public IEnumerable PegarPares(int[] numeros)
{
    List<int> pares = new List<int>()
    foreach (int n in numeros)
    {
        if (n % 2 == 0
            pares.Add(n);
    }
    return pares;
} 

Observe que foi preciso criar um List para armazenar todos os pares encontrados no vetor e então apos o foreach retornar o  IEnumerable.

Usando o operador yield, isso poderia ser feito assim:

public IEnumerable PegarPares(int[] numeros)
{
    foreach (int n in numeros)
    {
        if (n % 2 == 0)
            yield return n;
    }
}

Veja que legal, não é preciso criar nada pra armazenar os números pares.

Mas o operador yield possui algumas restrições:

1. Não pode ser usando em blocos inseguros (unsafe blocks)
2. Parâmetros para o método e nem usado como ref ou out

Quando se cria um método com o mesmo nome de um método da classe herdada, sendo que esse método não possui o modificador virtual é causado um warning, como abaixo:

'Demo.Filha.MetodoNaoVirtual()' hides inherited member 'Demo.Pai.MetodoNaoVirtual()'. Use the new keyword if hiding was intended.

Seu programa vai funcionar corretamente e esse método que foi criado sofrerá um override. Certamente é isso que você queria, mas como corrigir esse warning? É ai que o operado new entra na hitória. Basta adicionar-lo na assinatura do método. Um exemplo vai mais que mil palavras:

public class Pai
{

	public virtual string MetodoVirtual()
	{
		return "MetodoVirtual da classe Pai";
	}	

	public string MetodoNaoVirtual()
	{
		return "MetodoNaoVirtual da classe Pai";
	}
}

public class Filha : Pai
{

	public override string MetodoVirtual()
	{
		return "MetodoVirtual da classe Filha";
	}

	public virtual new string MetodoNaoVirtual()
	{

		return "MetodoNaoVirtual da classe Filha";
	}
}


public class Neta : Filha
{

	public override string MetodoNaoVirtual()
	{
		return "MetodoNaoVirtual da classe Neta";
	}
}

Observe que o método MetodoNaoVirtual da classe Pai não possui o operador virtual. E na classe Filha está havendo uma substituição do método usando operador new e virtual. Não é preciso usar os dois, coloquei para mostrar que na classe Neta o método está sendo substituído sem usar o operador new, isso porque na classe Filha foi adicionado o operador virtual.

Ler um RSS sem o uso do LINQ é preciso usar algumas estruturas de repetições, que pode até deixar o algoritmo um pouco confuso. A algum tempo atrás eu fiz um leitor de RSS em PHP (está hospedado no PHP Brasil), ficou em um ótimo algoritmo, mas deve ter dado 3x mais linha do que agora com o LINQ. 

Sempre me perguntei "Como será uma linguagem sem usar as comuns estruturas de condições e repetições?", mas depois que li um RSS usando LINQ, eu percebi minha pergunta já estava sendo respondida. Acredito que o LINQ será o PAI das novas linguagens.

Mas chega de tanto blablabla, abaixo está o exemplo:

protected void Page_Load(object sender, EventArgs e)
{
    if (!IsPostBack)
        CarregaRss(@"http://feeds.feedburner.com/magodigital");
}


protected void CarregaRss(string url)
{
    XDocument feedDoc = XDocument.Load(url);
    var query = from feed in feedDoc.Descendants("channel")
                select new
                {
                    Titulo = feed.Element("title").Value,
                    Descricao = feed.Element("description").Value,
                    Link = feed.Element("link").Value,
                    Itens = (from feedItens in feed.Descendants("item")
                             select new
                             {
                                 Titulo = feedItens.Element("title").Value,
                                 Link = feedItens.Element("link").Value,
                                 Descricao = feedItens.Element("description").Value
                             }).ToList()
                };
    var rss = query.Single();

    LblTitulo.Text = rss.Titulo;
    LblDescricao.Text = rss.Descricao;
    HypLink.Text = HypLink.NavigateUrl = rss.Link;
    GridItems.DataSource = rss.Itens;
    GridItems.DataBind();
}

Em Asp.NET:

<form id="form1" runat="server">
    Titulo :  <asp:Label ID="LblTitulo" runat="server" />
    Descricao: <asp:Label ID="LblDescricao" runat="server" />
    Link:  <asp:HyperLink ID="HypLink" runat="server" />
    <asp:GridView ID="GridItems" runat="server" />
</form> 

É muito comum precisar verificar se uma variável é nula, e se caso for, usar uma outra variável, bem o que quero dizer exatamente o código abaixo explica melhor:

string valorA = null;
string valorB = "Valor B";
string valorNaoNulo = (valorA != null) ? valorA : valorB;

No exemplo a cima é muito claro, pelo fato de valorA ser nulo a variável valorNaoNulo vai receber valorB. 

Usando o operado ?? do C# isso seria bem mais fácil e legível, observe código abaixo:

string valorA = null;
string valorB = "Valor B";
string valorNaoNulo = valorA ?? valorB;

O resultado será o mesmo, mas com o código mais enxuto.

Uma observação, como está na moda posta novos recursos do C# 3.0, é importante notar que o operador ?? é um recurso do C# 2.0