Un itérateur est une méthode qui permet d’utiliser un “foreach in” sur une classe. Jusqu’à maintenant, vous utilisiez le foreach in sur des collections. Exemple:

foreach(ListViewItem lvi in maListView.Items)
{
}

Vous ne pouviez donc travaillez que sur des objets de type Collection. C’est toujours le cas maintenant mais l’appel à ces collections se fait par l’appel à la classe parente de celles-ci. Prenons comme exemple, la classe Personne qui permet de contenir le nom et les différents prénoms d’une personne.

public class Personne
{
public string _Nom = “Morand”;
string[] _Prenoms = { “Louis-Guillaume”, “Charles”, “Aurélien”};
public System.Collections.IEnumerator GetEnumerator()
{
foreach (string prenom in _Prenoms)
yield return prenom;
}
}

// utilisation de l’itérateur
// instanciation de la classe Personne
Personne p = new Personne();

// itération à travers le foreach
foreach (string prenom in p)
{
Console.WriteLine(prenom);
}

Le mot-clé yield sert à retourner implicitement le type de l’objet retourné.

D’après la MSDN, les itérateurs ont les propriétés suivantes:
- une itérateur est une section de code retournant une suite ordonnée de valeurs
- un itérateur utilise le statement yield return pour renvoyer une valeur
- un itérateur peut être utilisé dans le corps d’une méthode ou dans un accesseur
- le type retourné par un itérateur doit être System.Collections.IEnumerable, System.Collections.IEnumerator ou l’un des itérateurs génériques

Source : developpez.com

La première chose à dire, est que ces derniers sont une  implémentation du concept de templates qui existait  déjà  en  C++.  Il  est  dorénavant  supporté  par  C#,  C++  et  VB.Net.
Le principe même des Generics est  la généralisation (et/ou réutilisation) de méthode sans ce soucier du typage des paramètres par exemples (transtypage).

Attention,  les  Generics  ne  sont  pas  identiques  aux  templates  du  C++,  ils  ont  encore  un  certain nombre de limitations:
-  il  n’est  pas  possible  d’utiliser  des  opérateur  arithmétiques  mais  on  peut  utiliser  des opérateurs personnels

-  les  paramètres  génériques  ne  peuvent  avoir  de  valeur  par  défaut

-  d’autres  limitations  dont  l’utilisation  très  rare  ne mérite  pas  de  se  pencher  dessus  pour  le moment

Cela paraîtra sûrement plus clair à l’aide d’un exemple concret:

static void Main(string[] args)
{
int a = 1, b = 5, c = 3;
List<int> myIntegerList = new List<int>();
myIntegerList.Add(a);
myIntegerList.Add(b);
myIntegerList.Add(c);
foreach(int val in list)
{
total = total + val;
}
}

Sans entrer dans les détails, nous verrons comment utiliser ce que l’on appelle une “Type-safe generic List”, une List (collection) dont le type est sûr. En effet, une List peut, de base accepter des objets de type différents qui sont alors “boxés” (rangés sans être castés dans un type différent), ainsi lors de la récupération des “items” de la List, nous ne savons pas le type de ces derniers et le unboxing peut entrainer des erreurs d’exécution. Ici, nous “créons” une collection ne contenant que des objets du type Integer, et l’opération de boxing/unboxing n’a plus lieu d’être. Les opérations sur cette collection sont alors plus “sécurisées”.

Bien sûr, il est possible de tirer avantage des Generics pour créer des classes réutilisables. En voici un exemple:

using System;
using System.Collections.Generic;
using System.Text;

namespace Developper
{
public class ClasseDemo< Type1, Type2 >
{
private Type1 _obj;
public ClasseDemo(KeyType obj1)
{
// constructeur
_obj = obj1;
}

public Type2 Method(Type2 obj1, Type2 obj2)
{
// Code fonctionnel
}
}
}

Ce bout de code est un peu spécial, mais je tenais à montrer la possiblité d’utiliser plusieurs paramètres génériques pour une seule et même classe. Cette dernière prend donc deux paramètres, l’un étant utilisé dans son constructeur, l’autre compare deux objets et retourne par exemple l’un des deux selon une certaine comparaison.

Ainsi, vous savez maintenant que les Generics et leurs nombreuses utilisations vous permettront de réduire la taille de votre code et de faire des classes, méthodes réutilisables à volonté.

Source : developpez.com

Première nouveauté intéressante, les méthodes anonymes. Elles permettent de construire une méthode sans la nommer ou, plus clairement, passer un bloc de code en tant que paramètre.
Voyons deux cas simples:

// Méthode anonyme avec une seule instruction
monBouton.Click += new EventHandler(sender, e)
{MessageBox.Show(”test”);};

// Méthode anonyme avec plusieurs instructions
monBouton.Click+= new EventHandler(sender, e)
{
string test = “Le bouton appuyé est ” + sender;
Console.WriteLine(test + ” avec l’event ” + e);
}

// avant vous auriez eu
monBouton.Click+= new EventHandler(this.maMethode)
…
private void maMethode(object sender, EventArgs e)
{
string test = “Le bouton appuyé est ” + sender;
Console.WriteLine(test + ” avec l’event ” + e);
}

Ainsi, pour des cas bien particuliers (par exemple lorsque vous savez que la méthode ne sera JAMAIS appelée autre part dans le code), il est possible d’appeler plusieurs lignes de code sans les mettre dans une méthode tierce. Ceci était déjà faisable en JAVA par exemple.

Source : developpez.com

Ce premier billet technique à pour but de présenter l’évolution du framework .Net, 5ans aprés la sortie de la version. Ce billet est une (très) simple modification d’une étude réalisé par Clever-age (Cabinet de conseil en architecture technique)

Source principale : http://www.clever-age.com/veille/clever-link/microsoft-.net-3.5-arrive-t-on-a-un-tournant.html

.NET Framework 1.0 : l’arrivée d’un Framework chez Microsoft

Avant l’arrivée de .NET, pour développer une application graphique (ou console), un service ou un site Web dynamique, nous devions faire un choix parmi une jungle de modèles de développement (COM, WIN32, MFC, Visual Basic Runtime, ATL, etc.) et les langages associés (VBScript, Visual Basic 6, C++, J++, etc.). Côté déploiement d’applications, l’« enfer des DLL » était le lot quotidien des équipes de développement et d’exploitation.

Read the rest of this entry »

Premier billet, de ce blog. Il a aura pour objectifs :

- de présenter les nouveautés du Framework 3.5 de .Net sortie en ce début d’année

- lister des astuces pour Visual Studio 2008

- parler des différentes certifications microsoft

- et enfin parler du développement en général