L’opérateur :: (ou qualificateur de namespace) permet d’appeler l’espace de nom global, lorsque ce dernier pourrait être caché par une entité (variable, méthode, propriété) locale du même nom. Ce n’est pas clair donc voici un exemple montrant un cas particulier où son utilisation est nécessaire :

class MaClasse
{
// définition d’une console nommée ‘console’

const int Console = 7;

static void Main()
{

Console.WriteLine(”Hello World”); // erreur: cela appelle
MaClasse.Console

// correction
::Console.WriteLine(”Hello World”);
}
}

Bien entendu, libre au développeur de ne pas utiliser des mots clés réservés, mais dans certains cas, cela peut-être nécessaire.

Source : developpez.com

Une variable de type nullable peut contenir toutes les valeurs possibles correspondant à son type, ainsi qu’une valeur additionnelle null. Ce problème résout entre autres le problème que vous pouviez rencontrer en travaillant avec des bases de données qui contenaient des variables null que vous ne pouviez “caster” correctement.

Prenons l’exemple le plus simple d’un entier (Integer) qui ne pouvait avec le Fx 1.1, être null.

int? monEntier = null;

Vous remarquez donc le caractère “?” à droite du type de l’objet que vous voulez nullable.

L’objet nullable se voit étendu de deux propriétés: HasValue qui retourne un booléen et Value qui retourne la valeur de l’objet. Ainsi, vous pouvez dorénavant tester la valeur d’un entier proprement:

if (monEntier.HasValue)
MessageBox.Show(”Valeur: ” + monEntier.Value);
else MessageBox.Show(”Valeur: nulle”);

Petite merveille, les classes partielles permettent de diviser une même classe dans plusieurs fichiers. Les “maniaques” du “une classe, un fichier” vont devoir revoir leur credo . Ces dernières sont principalement utilisées dans les cas de travail en équipe. Sans parler de CVS ou autre, chacun pourra coder son propre fichier de classe partielle qui, au moment de la compilation, se “fusionnera” avec les autres fichiers de cette même classe partielle. Prenons un exemple simple:

Classe normal passée en partielle (fichier du developpeur A)

partial class ClasseDeTest
{

// une variable
private string maVariable;

public ClasseDeTest()
{
// mon constructeur
}
}

Deuxième classe partielle (fichier du developpeur B)

partial class ClasseDeTest
{
//une methode
public void maMethode()
{
MessageBox.Show(maVariable);
}
}

Comme vous pouvez le voir, la méthode peut appeler des variables qui se trouvent dans la même classe mais dans un autre fichier. Dans un groupe de développeurs cela permet, entre autre, que chacun puisse créer séparement une partie d’une classe tout en pouvant utiliser les méthodes et variables codés par d’autres membres de l’équipe. Ou encore, séparer une grosse classe en la morcelant dans différents fichiers les membres, les constructeurs, les méthodes, etc.

Source : developpez.com

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