Code Music 2

using System;
using System.Text;
using Mundo;
 
namespace Funk
{
 public class SouFoda : IFunk
 {
  // Dig-din, dig-din, di-din
  this.Foda = true;

  public SouFoda()
  {
   Console.WriteLine(Foda.toString());
  }

  if(NaCama || NaSala || NoQuarto || NoBeco || NoCarro)
   this.Esculachar(vc);

  this.Sinistro = true;

  seuMarido.Qualidade = this.Qualidade * -1

  this.Esculachar(seuAmigo);

  while(NaCama)
   this.Perigoso = true;

  // Avassalador
  this.Interessante = true;

  this.Esculachar(seuAmante);
  this.Esculachar(seuFicante);

  Console.WriteLine("Não se esqueça");

  this.Vagabundo = true;

  Mundo.Putaria();

  #region [ REFRÃO ]
  for (i = 0; i < 2; i++)
  {
   for (i = 0; i < 2; i++)
    this.Enlouquecer(vc);

   foreach(Mulher m in queProvaram)
   m.Esquecer = false;
  }
  #endregion
 }
}

Code Music

Você sabe que música é essa?

this.NoOsso = true;

Biscoito b = new Biscoito();
Ganso g = new Ganso();

for(i = 2; i <= 8; i++)
 Console.Write(i);

this.Molhar(b);

this.Cansado = !this.NoOsso;

this.Afogar(g);

Expressões regulares

Expressões regulares são bem úteis e muitos programadores .NET acabam ignorando-as por serem herança do mundo Unix.

Porém, quando se dá a elas a devida atenção, vantagens são descobertas e códigos que levariam n+1 linhas para fazer validação de entrada, acabam por se apresentarem em apenas uma linha. Veja o exemplo de um método que valida telefones:

static bool IsPhone(string s)
{
    return Regex.IsMatch(s, @"^\(?\d{3}\)?[\s\-]?\d{3}\-?\d{4}$");
}

Mas o que raios é esse monte de treco entre as aspas?

Eu explico:

^ Representa o início da string. Quando você usa este símbolo, significa que você está trabalhando a string desde seu início.
\(? Um parênteses opcional. Para validar parênteses, é necessário usar com escape \ e para tornar o símbolo opcional, usa-se ?
\d{3} Três dígitos numéricos. \d significa dígito  e o número entre chaves identifica a quantidade que se está buscando.
\)? Fechamento de parênteses opcional. Novamente um parênteses, dessa vez fechando mas também é opcional graças ao ?
[\s\-]? Ou um ou outro. Nesse caso, estamos buscando OU um espaço vazio por \s OU um hifem por \- . Devido a estarem entre colchetes, nunca serão encontrados ao mesmo tempo. E seja lá qual for que encontremos, é opcional de qualquer maneira.
\d{3} Três dígitos. Isso eu já expliquei :D
\-? Um hífem. Apenas um hífem. Mas é opcional, se não tiver, tudo bem.
\d{4} Adivinha?
$ Final da string. Este símbolo indica o final da string. Como usamos ^ no começo e $ no final, estamos testando a string inteira.

Zenit Polar e texto ao contrário

Dois métodos simples. Apenas por diversão.

/// 

/// Criptografa usando o algorítmo Zenit Polar
/// 
/// O texto de entrada/// Texto criptografado
private string ZenitPolar(string p)
{
    String s;
    s = p;

    s = s.Replace("z", "wx");
    s = s.Replace("p", "z");
    s = s.Replace("wx", "p");

    s = s.Replace("e", "wx");
    s = s.Replace("o", "e");
    s = s.Replace("wx", "o");

    s = s.Replace("n", "wx");
    s = s.Replace("l", "n");
    s = s.Replace("wx", "l");

    s = s.Replace("i", "wx");
    s = s.Replace("a", "i");
    s = s.Replace("wx", "a");

    s = s.Replace("t", "wx");
    s = s.Replace("r", "t");
    s = s.Replace("wx", "r");

    return s;
}

/// 

/// Inverte o texto
/// 
/// O texto de entrada/// O texto invertido
private string Reverse(string txt)
{
    StringBuilder sb = new StringBuilder();

    for (int i = txt.Length; i > 0; i--)
        sb.Append(txt[i-1]);

    return sb.ToString();
}

Código Fonte do Windows Vista