Method extension MSDN

Aqui fica um exemplo que achei interessante sobre extensão de metodos em .net

namespace Extensions
{
using System;
using ExtensionMethodsDemo1;

// Define extension methods for any type that implements IMyInterface.
public static class Extension
{
public static void MethodA(this IMyInterface myInterface, int i)
{
Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, int i)");
}

public static void MethodA(this IMyInterface myInterface, string s)
{
Console.WriteLine("Extension.MethodA(this IMyInterface myInterface, string s)");
}

// This method is never called, because the three classes implement MethodB.
public static void MethodB(this IMyInterface myInterface)
{
Console.WriteLine("Extension.MethodB(this IMyInterface myInterface)");
}
}
}
namespace ExtensionMethodsDemo1
{
using System;
using Extensions;

public interface IMyInterface
{
void MethodB();
}

class A : IMyInterface
{
public void MethodB(){Console.WriteLine("A.MethodB()");}
}

class B : IMyInterface
{
public void MethodB() { Console.WriteLine("B.MethodB()"); }
public void MethodA(int i) { Console.WriteLine("B.MethodA(int i)"); }
}

class C : IMyInterface
{
public void MethodB() { Console.WriteLine("C.MethodB()"); }
public void MethodA(object obj) { Console.WriteLine("C.MethodA(object obj)"); }
}

class ExtMethodDemo
{
static void Main(string[] args)
{
A a = new A();
B b = new B();
C c = new C();
TestMethodBinding(a,b,c);
}

static void TestMethodBinding(A a, B b, C c)
{
// A has no methods, so each call resolves to
// the extension methods whose signatures match.
a.MethodA(1); // Extension.MethodA(object, int)
a.MethodA("hello"); // Extension.MethodA(object, string)
a.MethodB(); // A.MethodB()

// B itself has a method with this signature.
b.MethodA(1); // B.MethodA(int)
b.MethodB(); // B.MethodB()

// B has no matching method, but Extension does.
b.MethodA("hello"); // Extension.MethodA(object, string)

// In each case C has a matching instance method.
c.MethodA(1); // C.MethodA(object)
c.MethodA("hello"); // C.MethodA(object)
c.MethodB(); // C.MethodB()
}
}
}
/* Output:
Extension.MethodA(this IMyInterface myInterface, int i)
Extension.MethodA(this IMyInterface myInterface, string s)
A.MethodB()
B.MethodA(int i)
B.MethodB()
Extension.MethodA(this IMyInterface myInterface, string s)
C.MethodA(object obj)
C.MethodA(object obj)
C.MethodB()
*/

Collection generic

Um exemplo de como utilizar uma colecção generica, no meu ponto de vista é melhor que os arrays, pq nos arrays muitas vezes, se não for dinamica, temos que especificar um tamanho para o contentor, mas pode ocorrer que não sabemos o tamanho que poderá ser introduzido no contentor. Por isso introduzimos numa lista, e podemos usar a propriedade Count para saber quantos elementos estão a ser alojados nesta colecção.

List myInts = new List();

myInts.Add(1);
myInts.Add(2);
myInts.Add(3);

foreach(Int32 i in myInts)
{
Console.WriteLine("MyInts: {0}", i);
}

Windows 7 God's mode

Para os curiosos e para quem gosta de "brincar" um pouco com estas coisas, aqui vai uma sugestão. No desktop criem uma pasta com o nome

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

Está pasta irá conter vários aspectos de configuração do windows 7.
Explorem pode ser engraçado...

enum em c#, asp.net

Trabalhando com objectos do tipo enum.

Podemos ter o interesse de converter uma string para o nosso tipo enum.
Como podemos ver no exemplo a seguir usamos o Parse como seria de esperar em tipos valor como Int32, Double,...

object Enum.Parse(System.Type enumType, string value, bool ignoreCase);So you can

enum Colour
{
Red,
Green,
Blue
}

Colour c = (Colour) Enum.Parse(typeof(Colour), "Red", true);
Console.WriteLine("Colour Value: {0}", c.ToString());

Podemos proteger o nosso código de forma a verificar se a cor existe, caso não exista o mais comum resultado é uma excepção. Assim fazemos um teste a ver se a cor está definida no enum.

string nonColour = "Isto Não é uma cor";

if (Enum.IsDefined(typeof(Colour), nonColour))
c = (Colour) Enum.Parse(typeof(Colour), nonColour, true);
else
MessageBox.Show("Uh oh!");

A forma a seguir é usando um metodo generico para devolver T, o tipo de enum que estamos a usar.

public static T StringToEnum(string name)
{
return (T)Enum.Parse(typeof(T), name);
}

Color c = StringToEnum("Red");

public enum DaysOfWeek
{
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}

DaysOfWeek d = StringToEnum("Monday");


Como programadores que gostamos de proteger o nosso código de excepções que possam ocorrer, podemos ainda ter este metodo verificando se name está definido no enumerado.

public static T StringToEnum(string name)
{
if (Enum.IsDefined(typeof(T), name))
return (T)Enum.Parse(typeof(T), name);
else
MessageBox.Show("Uh oh!");
// no else fazemos qualquer coisa que faça sentido no nosso código
// pode ser mandar uma excepção de aplicação neste caso especifico...
}


Podemos ainda fazer uma extensão deste metodo para o objecto string se for muito usado.

Não testei este código mas já usei parecido, por isso não deve estar muito longe da realidade.

Alojamento Gratuito

Aqui fica uma sugestão para quem quiser "brincar" e alojar uma página em Asp.net.
Serve para alojar um website de forma gratuita e poder aprender, realizar testes e termos disponivel na internet o que estamos a implementar.

http://www.aspspider.com/

IPAD

É oficial: o novo 'gadget' da Apple chama-se iPad.

APPLE