Jiri's Shared IT knowledge

mardi, juillet 26, 2005

SharePoint (SPS 2003/WSS) : Si on parlait de la Version 3 ...

La release de VS 2005 arrive, SQL Server 2005 aussi et à petit pas
Et de la, le futur de SharePoint Technologies commence lui aussi à se dessiner
Mais tout doucement.

Mike Fitzmaurice (WSS/SPS Senior developer evangelism) vient de confirmer certains points et léve le voile sur d'autre.

Des lors, que pouvons nous attendre de SharePoint ???
Mais avant parlons déja de la version actuelle !!! Et oui SPS 2003 / WSS n'est pas encore remplacé.

  1. Il est largement déconseillé (et non supporté) d'installer conjointement Whidbey et WSS/SPS, et je ne parle pas de Yukon>>> Préféré un scenario de test avec une machine Virtuel style VPC/VMWARE. Même Si aprés quelques paramétrages, les 2 peuvent plus ou moins coexister, il n'en reste pas moins que la stabilité d'une telle configuration tient plus d'une bouteille de nitroglycerine qu'autre chose...
  2. Si la notion de User Control dans SharePoint vous interesse (à la maniére des GenericsControls & les WebParts de VS 2005), jettez donc un oeil sur la SmartPart

    Maintenant, projettons nous un peu plus loin dans le futur

  1. Comme déja dit, le CAML est la pour encore qque temps. Bien, trés bien mais il ne semble pas que Ms aille sortir un CAML Viewer/Editor pour VS 2005>>> Bref, XmlSpy/Cooktop et d'autre editeur XML ont encore de beau jour >>> C'est aussi un axe intéréssant pour un editeur de plugin
  2. SharePoint V3 sera basé sur ASP.NET 2.0 et son framework de WebPart>>> Que dire de plus, je ne vois pas... (mais pas d'information sur la notion de master template ....)
  3. Les WebParts de la V3 ne fonctionneront que sur des sites sous technologie SharePoint V3. Un site ASP.NET 2.0 ne pourra donc les utiliser ...
  4. Il y aura une totale compatibilité entre les WebParts actuelles et les WebParts de la V3>>> Rien n'empêche donc d'attendre, vous pouvez commencer à coder vos composant dés maintenant !
  5. Attention, .Net sera prépondérant sur la V3 mais la notion de IFilter et de Protocol Handler restera en C++
  6. La V3 ne sera pas sorti cette année même si Whidbey vas arriver

Plein de bonne chose n'est ce pas ? Masi ce n'est pas tout !
Parlons un peu du service Pack 2 de SPS 2003/ WSS :

  1. Ce SP permettra de faire fonctionner conjointement ASP.NET 2.0 ET SPS 2003/WSS
  2. la liste des fonctionnalités de ce SP n'est pas encore publique et donc rien n'est garantie si ce n'est le fonctionnement conjoint
Il est souvent question d'utiliser les WP de whidBey dans WSS SP2.
C'est actuellement en cours de travail chez les équipes de MS :

Il ne faut donc pas, pour autant, être sur que ce sera une fonctionnalité du SP2
(Disons plutot une bonne surprise si jamais, croisons les doigt)

Dixit Mike Fitzmaurice:"But don’t plan to use them (Whidbey WP) in SharePoint sites for a year. Believe me, no one will be happier than me when we can tell everyone to write all Web Parts in ASP.NET 2.0, and if we can tell you this before next year, we will."

Donc en résumé :
  • Plein de bonne chose pour l'avenir avec ASP.NET 2.0
  • Preparez vous en testant les WP de Whidbey : voici un bon article
  • Evitez de tout installer sur la même machine.
  • Continuez à écrire des WP ! (en attendant l'année prochaine voir plus)

jeudi, juillet 14, 2005

Innovations du langage C# 2.0

Attaquons les innovations d’un premier langage : « C# », entendez C Sharp. Nous aborderons les Générics, les classes partielles, les méthodes anonymes, les itérateurs, les qualifications d'alias et des classes statiques, ... Les explications se voudront relativement simples en vue de permettre une compréhension rapide de ces avancées.

1. Générics
Présenté comme étant une des caractéristiques prépondérantes, soutenue par Bill Gates, du C# 2.0, les Générics apportent la capacité de réutilisation générique des algorithmes. Couramment utilisé en C++ comme Template, l’absence des Générics sous C# fut un reproche des utilisateurs auprès de Microsoft. Avant l’apparition des génériques, nous aurions écrit le code suivant :

public class List
{
private object[] elements;
private int count;
public void Add(object element) {
if (count == elements.Length) Resize(count * 2);
elements[count++] = element;
}
public object this[int index] {
get { return elements[index]; }
set { elements[index] = value; }
}
public int Count {
get { return count; }
}
}
En l’exploitant de la manière suivante : List intList = new List();
intList.Add(1); // Boxing
intList.Add(2); // Boxing
intList.Add("Three"); // Génère une erreur à l’exploitation du code
int i = (int)intList[0]; // Le Cast est nécessaire
Cette méthodologie, bien que fonctionnelle, soulève quelques problématiques : le transtypage explicite nécessaire, la diminution des performances de ce code lors de l’étape implicite de boxing et unboxing des éléments, la possibilité d’empiler des éléments de types différents pouvant engendrer des problématiques de transtypages uniquement décelables lors de l'exécution du code, nous parlerons dans ce cas de code non Type-Safe. L’entrée des Générics permet d’écrire le code suivant : public class List
{
private T[] elements;
private int count;
public void Add(T element) {
if (count == elements.Length) Resize(count * 2);
elements[count++] = element;
}
public T this[int index] {
get { return elements[index]; }
set { elements[index] = value; }
}
public int Count {
get { return count; }
}
}
Et une exploitation : List intList = new List();
intList.Add(1); // Pas de boxing
intList.Add(2); // Pas de boxing
intList.Add("Three"); // Erreur levee lors de la compilation
int i = intList[0]; // Aucun Cast nécessaire

Cette nouveauté permet ainsi d’éviter les problématiques mentionnées sans utilisation des Générics. Nous avons ainsi un code performant, Type-Safe n'engendrant aucune opération de boxing/unboxing sans transtypage des éléments.

2. Classes partielles

Les classes partielles représentent une nouveauté intéressante et plus particulièrement dans le cadre du travail collaboratif. L’approche est simple, à l’avenir les classes pourront être écrites sur plusieurs fichiers grâce à la syntaxe " public partial class …"

Exemple : // ClassPart1.cs
using System;
public partial class ClassPart
{
public void Methode()
{
}
}


// ClassPart2.cs
using System;
public partial class ClassPart
{
public void AutreMethode()
{
}
}

Une nuance à ce titre entre VB.NET et C#, VB.NET tolère une classe déclarée en «Public Class».

3. Méthodes anonymes
Les méthodes anonymes permettent d'instancier une méthode sans la nommer. Contrairement aux Générics, cette nouveauté n'engendre aucune nouvelle implémentation au sein de l’IL (Intermediate Language) mais se situe au niveau du compilateur.

button.Click += delegate { MessageBox.Show("HelloWorld"); };

L’exemple suivant montre une méthode anonyme avec des arguments.

button.Click += delegate(object sender, EventArgs e) {
MessageBox.Show(((Button)sender).Text);
};

4. Itérateurs
Les itérateurs peuvent être considérés comme étant la contre partie logique C# 2.0 du foreach sous C#. Les itérateurs simplifient le processus d'itération de collection.

En C#, il est relativement simple de itérer des collections finies d’éléments en utilisant le mot clé « foreach ». Ceci nécessite l’implémentation des interfaces IEnumerable et IEnumerator.

L’objectif premier des itérateurs est d'alléger le travail d'écriture des zones fixes de code et de rendre plus simple l'exposition de collection énumérables.

class List: IEnumerable
{
private T[] elements;
public IEnumerator GetEnumerator()
{
foreach (T element in elements)
{
yield element;
}
}
}


Nous n’oublierons pas d’implémenter « System.Collections.Generic » afin d’exploiter la version Generic de IEnumerator : « using System.Collections.Generic; »

Vous aurez aussi remarqué l’utilisation d’un nouveau mot clé « yield » qui est utilisé dans notre méthode comme retour de IEnumerator, IEnumerable ou tout autre Generic équivalent. Tout comme les méthodes anonymes, les itérateurs gèrent des arguments.

5. Qualificateur global d’espace de nom
L’accès à un membre dans l’espace de nom global s’avère être utile quand le membre pourrait être caché par une autre entité du même nom.

Le qualificateur global d’espace de nom résout ce problème par l’introduction de l'opérateur ": :" qui peut être employé comme espace de nom ou type préfixe nommé.

namespace Acme
{
namespace System
{
class Example
{
static void Main()
{
::System.Console.WriteLine("Hello");
}
}
}
}


6. Classes Statiques
Les classes statiques prévoient de remplacer les design patterns de création de classes de type « sealed » avec un constructeur "private" contenant uniquement des méthodes statiques.
Le code suivant :

public sealed class Environment
{
// Keep class from being created
private Environment() { }
}

Devient :
public static sealed class Environment
{
}

L'avantage d'employer une classe statique au lieu du modèle de conception ci-dessus est que le compilateur peut maintenant rapporter une erreur si des instances de méthodes sont accidentellement déclarées

7. Types Nullables
Si vous n’aviez jamais imaginé assigner des valeurs nulles à vos types « valeur », détrompez-vous ! Vous pouvez désormais assigner des valeurs nulles à des types valeur en définissant un type nullable. Ceci en ajoutant un point d'interrogation "?" immédiatement à droite du type lors de la définition de votre variable. Les types nullables dérivent du type générique System.Nullable. T étant votre type. Deux propriétés étendent l'utilité des types nullables : "HasValue" et "Value". HasValue évalue le caractère « nulle » de votre type tandis que Value retournera la valeur fondamentale que celle-ci soit nulle ou non.

//les deux déclarations suivantes se réfère au même type nullable d'interger
int? myInt1 = null; Nullable myInt2 = null;
if (myInt1 == null) Console.WriteLine("myInt1 is null."); if (myInt2 == null) Console.WriteLine("myInt2 is null.");
// Nous pouvons examiner le type valeur pour nous assurer d’obtenir une valeur de cette manière
myInt1 = 1; if (myInt1.HasValue) Console.WriteLine("myInt1 has a value = {0}", myInt1.Value); else Console.WriteLine("myInt1 is null.");