string email = Request.QueryString["email"];

if ( EmailValidator.IsValid(email) ) {
   
}

string email = Request.QueryString["email"];

if ( email.IsValidEmailAddress() ) {
   
}

Hiervoor maak je een extension method voor de klasse string:

namespace MyExtensions
{
	public static class MyExtensionClass
	{
		public static bool IsValidEmailAddress(this string s)
		{
			Regex regex = new Regex(@"^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$");
			return regex.IsMatch(s);
		}
	}
}

Het sleutelwoord this in de methode vertelt de compiler dat deze methode een extension method is voor het type dat volgt, hier dus het type string.
Werk je in dezelfde namespace als je project-file, dan is de extension-methode direct te gebruiken.

Bevindt de extension method zich in een aparte class-library en namespace, dan doe je twee zaken:

• Leg een referentie naar de dll met de extension method
• Voorzie in je programma een using statement:

  using MyExtensions;
  

• That's it, string heeft nu een methode IsValidEmailAddress!

Het ultieme voorbeeld hiervoor kunnen we maken door een extension method te maken voor een object.

public static class MyExtensionClass
{

	public static bool In(this object o, IEnumerable c)
	{
		foreach (object i in c)
		{
			if (i.Equals(o)) 
				return true;
		}
		return false;
	}
}

Deze klasse kan dus voor elk object kijken of het voorkomt in een reeks van elementen die de interface IEnumerable implementeert, zoals collecties.

De methode In heeft nu natuurlijk tal van toepassingsmogelijkheden:

• Komt een string voor in een Array van strings?

  string[] dieren = { "aap", "beer", "konijn", "wolf" };
  if ("beer".In(dieren))
  	Console.WriteLine("beer gevonden in dieren");
  

• Controleren of een TextBox voorkomt in een ASP.Net form:

  void Page_Load()
  {
  	if(TextBox1.In(form1.Controls))
  	{
  	 //TextBox1 komt voor in de form
  	}
  }
  

Veel van deze methoden worden verderop in de cursus uitgebreider besproken, maar hier volgt al een eerste kennismaking.

• Maak een klasse Person:

  public class Person {
          public string FirstName { get; set; }
          public string LastName  { get; set; }        
          public int    Age       { get; set; }
  }
  

• Maak in een Console-Toepassing een collectie people:

  static void Main(string[] args)
  {
  	List<Person> people = new List<Person> {
     		new Person { FirstName = "William", LastName = "Schokkele", Age = 35 },
     		new Person { FirstName = "Bill", LastName = "Gates", Age = 50 },
     		new Person { FirstName = "Hanne", LastName = "Schokkele", Age = 7 }
  	};
  }
  

Where

• Pas de extension method Where toe uit de namespace System.Linq:

  IEnumerable personen;
  personen = people.Where(p => p.LastName.StartsWith("S"));
  
  foreach (Person p in personen)
  {
  	Console.WriteLine(p.FirstName +" " + p.LastName);
  }
  

  De p => uitdrukking is een voorbeeld van een Lambda-expressie. Dit is een compacte toepassing van anonieme methoden in C#, en komt straks uitgebreider aan bod.

  

Average, Max

• De gemiddelde en de hoogste leeftijd bepalen we met de extensionm methods Average en Max:

  double gemiddeldeLeeftdijd = people.Average(p => p.Age);
  int hoogsteLeeftijd = people.Max(p => p.Age);
  Console.WriteLine("Gemiddelde leeftijd: " +gemiddeldeLeeftdijd.ToString());
  Console.WriteLine("Hoogste leeftijd: " + hoogsteLeeftijd.ToString());
  

  

• Voorzie een nieuw XML-bestand People.xml in de bin\debug map van de toepassing:

  <?xml version="1.0" encoding="utf-8" ?>
  <people>
  	<person age="35">
  		<firstname>William</firstname>
  		<lastname>Schokkele</lastname>
  	</person>
  	<person age="50">
  		<firstname>Bill</firstname>
  		<lastname>Gates</lastname>
  	</person>
  	<person age="7">
  		<firstname>Hanne</firstname>
  		<lastname>Schokkele</lastname>
  	</person>
  </people>
  

  Where

• De voornamen van de personen waarvan de familienaam start met een "S":

  XDocument people = XDocument.Load("People.xml");
  IEnumerable<XElement> personen;
  
  personen = people.Descendants("person")
  	.Where(p => p.Element("lastname").Value.StartsWith("S"));
  
  foreach (XElement p in personen)
  {
  	Console.WriteLine(p.Element("firstname").Value);
  }
  

  

  We hebben nu eigenlijk een untyped collectie van XElement-objecten.

  Linq maakt het mogelijk deze elementen te shapen (typecasten naar het gewenste object) met de extension method Select:

  XDocument people = XDocument.Load("People.xml");
  IEnumerable<Person> personen;
  
  personen = people.Descendants("person")
  	.Where(p => p.Element("lastname").Value.StartsWith("S"))
  	.Select(p => new Person
  	{
  		FirstName = p.Element("firstname").Value,
  		LastName = p.Element("lastname").Value,
  		Age = Convert.ToInt32(p.Attribute("age").Value)
  	});
  
  foreach (Person p in personen)
  {
  	Console.WriteLine(p.FirstName);
  }
  
  

Average, Max

double gemiddeldeLeeftdijd = people.Descendants("person").Average(p => Convert.ToInt32(p.Attribute("age").Value));
int hoogsteLeeftijd = people.Descendants("person").Max(p => Convert.ToInt32(p.Attribute("age").Value));

• Start een nieuwe Console-Applicatie
• Maak met SQL Server management studio een nieuwe SQL-Server Express database PeopleDB.

  

• Voorzie volgende records:

  

• Maak met Server Explorer een dataconnectie naar PeopleDB:

  

• Voeg een nieuw item "Linq to SQL Classes" PeopleDB.dbml toe:

  

• Sleep de tabel People vanuit Server Explorer in de designer en hernoem de klasse Person:

  

  Where

• Voorzie in de methode Main van de applicatie:

  PeopleDBDataContext peopledb = new PeopleDBDataContext();
  IEnumerable<Person> personen;
  
  personen = peopledb.Persons.Where(p => p.Lastname.StartsWith("S"));
  
  foreach (Person p in personen)
  {
  	Console.WriteLine(p.Firstname);
  }
  

  

  Average, max

  double gemiddeldeLeeftdijd = personen.Average(p => p.Age);
  int hoogsteLeeftijd = personen.Max(p => p.Age);