La surcharge d’opérateur permet de donner aux opérateurs un comportement spécifique quand ils sont appliqués à des types spécifiques. Plus simplement, on peut définir le “comportement” qu’engendre l’utilisation d’un opérateur binaire sur deux objets d’un type défini.

Prenons un exemple on ne peut plus simple, la surcharge de l’opérateur “-” (soustraire).

Public Shared Operator -(ByVal str1 As MyString, _
ByVal str2 As MyString) As String
Return str1.Text.Substring _
(0, str1.Text.Length - _
str2.Text.Length) & str2.Text
End Operator

Les opérateurs surchargés remplacent avantageusement les appels de fonction, car ils nous évitent ici décrire une méthode effectuant la “soustraction” et retravaillant les deux chaines de caractères

Les différents opérateurs qu’il est possible de surcharger sont: “+”, “-”, “*”, “/”, “^”, “<”, “<=”, “>”, “>=”, “<<”, “>>;”, “&”, “Like”, “Mod”, “And”, “Or”, “Xor”, “Not”, “=”, et quelques autres.

Avec le nouveau CLR 2.0 , VB.Net peut maintenant utiliser les types entiers non-signés. Ces nouveaux types sont donc UShort, UInteger, ULong et SByte.
Pour ceux qui ne verraient pas l’intérêt de ses types, il faut savoir que l’utilisation de type non-signés pour stocker des entiers que l’on a par exemple, forcément positifs, permet d’avoir les meilleurs performances possibles sur des plateformes 32bits et donc pour votre application.

Comme pour C#, il est maintenant possible d’utiliser les classes partielles en VB.Net 2.0.

Pour plus d’informations, merci de voir le billet suivant : Les classes partielles en C#

VB.Net, contrairement au C#, ne nécessite par que toutes les “même” classes partielles aient le mot partial. Une (seule!!) d’entre elles peut ne pas l’avoir.

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