Desert Dev

Tutoriel WCF

2011-07-15T14:13:00.001+01:00

Dans ce tutoriel on va essayer d'introduire à travers un exemple illustratif la technologie WCF qui a pour but de faciliter la communication entre les processus locaux ou distants et permettant ainsi un développement souple et performant.
Le principe est très simple, on a un serveur exposant un ou plusieurs services à des clients distant, dans notre cas le serveur offre un service d'inversement de chaines de caractères.

En premier lieu nous avons besoins de définir les service que le client peut accéder, c-à-d les services exposés par le serveur. Cela est est réalisé à travers la définition de l'interface c# suivante:

using System;

using System.ServiceModel;

[ServiceContract]

public interface IStringReverser

{

  [OperationContract]

  string ReverseString(string value);

}

Comme on peut le constater, celle-ci est une interface simple qui définisse la méthode ReverseString qui prend comme argument une chaine de caractère nommée value et retourne un résultat du même type (String).

L'attribut [ServiceContract] indique que cette interface peut être exposée au client en tant que service, tandis que l'attribut [OperationContract] indique que la méthode ReverseString fait partie de ce service et peut etre ainsi utilisé par les clients.

 Notons bien que l'ajout de l'espace de nom System.ServiceModel au références du projet est requis.

Començons par implémenter notre serveur, en premier lieu on doit créer une classe qui implemente l'interface du service . le code de cette classe est illustré par le code suivant:

using System;

using System.ServiceModel;

[ServiceContract]

public interface IStringReverser

{

  [OperationContract]

  string ReverseString(string value);

}

public class StringReverser : IStringReverser

{

  public string ReverseString(string value)

  {

    char[] retVal = value.ToCharArray();

    int idx = 0;

    for (int i = value.Length - 1; i >= 0; i--)

      retVal[idx++] = value[i];

    return new string(retVal);

  }

}

maintenant on doit ajouter une autre classe permettant de rendre fonctionnel notre serveur à travers la creation d'un ServiceHost (hébergeur de service)qui est responsable sur l'exposition et la communication dans le service.

La nouvelle classe (Main) du serveur sera donc la suivante:

class Program

{

  static void Main(string[] args)

  {

     ServiceHost host=new ServiceHost(typeof(StringReverser), 
                                    newUri("http://localhost:8000"));

      host.AddServiceEndpoint(typeof(IStringReverser),

        new BasicHttpBinding(),

        "Reverse");

      host.Open();

      Console.WriteLine("Service is available. " + 

        "Press  to exit.");

      Console.ReadLine();

      host.Close();

  }

}

l'objet host représente notre service host ou hebergeur de notre service, ici on a utilisé comme adresse http://localhost:8000 pour indiqué que le service est hébergé sur le poste local.

 host.AddServiceEndpoint(...) permet de définir le point d'acces ("Reverse") de notre service et le protocole de communication (asicHttpBinding).

ensuite il ne reste que lancer le service avec la commande host.Open(). 

Le code complet de notre serveur sera dons le suivant:

using System;

using System.ServiceModel;

namespace WCFServer

{

[ServiceContract]

public interface IStringReverser

{

  [OperationContract]

  string ReverseString(string value);

}

public class StringReverser : IStringReverser

{

  public string ReverseString(string value)

  {

    char[] retVal = value.ToCharArray();

    int idx = 0;

    for (int i = value.Length - 1; i >= 0; i--)

      retVal[idx++] = value[i];

    return new string(retVal);

  }

}

class Program

{

  static void Main(string[] args)

  {

     ServiceHost host=new ServiceHost(typeof(StringReverser), 
                                    newUri("http://localhost:8000"));

      host.AddServiceEndpoint(typeof(IStringReverser),
newBasicHttpBinding(),"Reverse");

      host.Open();

Console.WriteLine("Service is available. "+
"Press  to exit.");
Console.ReadLine();

      host.Close();
}
}

} 

Passons maintenant au client, en premier lieu, on doit définir la même interface du service offerte par le serveur.
En second lieu, on doit définir un proxy et un canal de communication entre le client et le serveur ce qui permettant ainsi l'echange des messages. Pour cela, on va utiliser la classe ChannelFactory offerte par WCF.

 Le code du client sera donc comme suit:

using System;

using System.ServiceModel;

using System.ServiceModel.Channels;

namespace WCFClient

{

  [ServiceContract]

  public interface IStringReverser

  {

    [OperationContract]

    string ReverseString(string value);

  }

  class Program

  {

    static void Main(string[] args)

    {

      ChannelFactory<IStringReverser> httpFactory =

        new ChannelFactory<IStringReverser>(

          new BasicHttpBinding(),

          new EndpointAddress("http://localhost:8000/Reverse"));

      IStringReverser httpProxy =

        httpFactory.CreateChannel();

      while (true)

      {

        string str = Console.ReadLine();

        Console.WriteLine("http: " + 

          httpProxy.ReverseString(str));

      }

    }

  }

}

trop simple non ?, WCF facilite beaucoup le développement des applications distribuées par l'abstraction de la partie communication et les développeurs n'ont qu'a definir les services et leurs mode de communication.

Télécharger le code source de l'exemple ici 

.

Recuperer la liste des fichiers en c# -tutoriel C#

2010-10-28T16:56:00.002+01:00

Pouvez vous me dire combien de fichier existe-il sur l'un de vos disques C: ,D: ou sur la totalité de l'ordinateur?

il y a plusieurs situations ou le développeur est obligé de récupérer des informations pareilles ,et un grand merci a l'espace de noms System.IO qui nous facilite beaucoup les choses ., car tous ce que nous avons a faire c'est de créer une variable et une boucle.

pour commencer on doit ajouter l'espace de nom System.IO parce qu'il n'est pas utilisé par défaut ,
Ensuite, nous allons créer une nouvelle instance de la classe DirectoryInfo, et dans ce cas, nous utilisons le lecteur racine de C: \ comme paramètre (parce que on veux avoir des informations sur ce dernier), de sorte que le code devrait ressembler à:

DirectoryInfo fileListing = new DirectoryInfo("C:\\");

Ce code  fait exactement ce que vous pensez, il prend le répertoire et vous permet  d'obtenir toutes sortes d'informations  (permissions,Date de creation,Derniere date de modifications ...etc)

Maintenant  que nous avons notre objet DirectoryInfo, nous pouvons parcourir tous  les fichiers de ce répertoire et faire n'importe quoi avec eux.Dans notre cas , on vaut seulement Remplir une ListBox avec le chemin Complet des Fichiers . pour faire cela on doit appeler la methode GetFiles() qui retourne un tableau d'objets de type FileInfo.

chaque FileInfo contient une tonne d'informations , mais tous ce qu'on a réellement besoin c'est le nom  ,Donc, notre code final pourrait ressembler à:

DirectoryInfo fileListing = new DirectoryInfo("C:\\");

foreach (FileInfo file in fileListing.GetFiles())

{

  listBox1.Items.Add(fileListing.ToString() + file.Name);

}
Super simple mais soyons honnêtes, combien de fois on a besoin de tous les fichiers dans un répertoire ?! Pas très souvent, mais heureusement la Méthode  GetFiles()accepte un argument "Modèle de Recherche" pour Limiter les FileInfo retournés dans le résultat.

Cet argument est juste une chaîne de caractères ,disons que nous voulons chercher des fichiers text (.txt) Alors Notre code de mise à jour sera le suivant:

DirectoryInfo fileListing = new DirectoryInfo("C:\\");
foreach (FileInfo file in fileListing.GetFiles("*.txt"))

{

  listBox1.Items.Add(fileListing.ToString() + file.Name);

}

le seul inconvenant dans l'utilisation du modèle de recherche c'est qu'on ne peux utiliser qu'un seul modèle c-a-d on ne peux chercher qu'un seul type de fichier a la fois, et pour remédier a ce problème on n'a qu'a appeler la méthode GetFiles() plusieurs fois avec comme paramètre le type de fichier adéquat, pas plus simple que cela ;) .

Jouer avec le Switch -Tutoriel c#

2010-09-21T16:28:00.005+01:00

Aujourd'hui, nous allons jeter un œil sur le switch. Plus précisément, nous allons voir certains des comportements les moins connus de l'instruction switch en C #.

1-

public void FaireUnSwitch(int nbr)
{
switch (nbr)
{
case 0:
case 1:
case 2:
Console.WriteLine("Je suis dans le cas 0, 1 ou 2!");
break;
case 3:
case 4:
case 5:
Console.WriteLine("je suis dans le cas 3, 4 ou 5!");
break;
}
}

en écrivant le code de cette manière en regroupant les cases on dit que:

"pour 0,1,2 faire l'instruction X, et pour 3,4,5 faire l'instruction Y"

2-

public enum State { One, Two, Three, Four };

switch (mystate)
{
case State.One:
Console.WriteLine("Je suis dans l'etat: one!");
break;
case State.Two:
Console.WriteLine("Je suis dans l'etat: two!");
goto case State.Four;
case State.Three:
Console.WriteLine("Je suis dans l'etat: three!");
goto case State.Two;
case State.Four:
Console.WriteLine("Je suis dans l'etat: four!");
goto case State.One;
}

en C# on a la possibilité de faire un goto vers un label (étiquette), ce qui veut dire qu'on peut aller executer n'importe quel case, nous voulons à tout moment .
si vous essayez d'executer le code precedant avec comme parametre mystate=three , vous aurez le resultat suivant :

Je suis dans l'etat: three!
Je suis dans l'etat: two!
Je suis dans l'etat: four!
Je suis dans l'etat: one!

Cool, non? c'est pas encore fini, nous avons un peu d'excitation en plus. Vous pouvez également utiliser cette instruction goto pour aller au bloc par défaut dans une instruction switch. Par exemple

public enum State { One, Two, Three, Four };

public static void FaireUnSwitch(State mystate)
{
switch (mystate)
{
case State.One:
Console.WriteLine("I'm in state one!");
break;
case State.Two:
Console.WriteLine("I'm in state two!");
goto default;
case State.Three:
Console.WriteLine("I'm in state three!");
goto default;
case State.Four:
Console.WriteLine("I'm in state four!");
goto default;
default:
Console.WriteLine("I'm at the default!");
break;
}
}

Ici, dans tous les cas sauf pour State.One, nous allons au bloc default (par défaut) avant de quitter

il faut bien faire attention lorseque on ecrit des saut explicites pareils car il est tres facile a entrer dans une boucle infinie ! .

En fait, le compilateur vous permet même de faire quelque chose aussi bête que cela:

public enum State { One, Two, Three, Four };

public static void DoASwitch(State mystate)
{
switch (mystate)
{
case State.One:
Console.WriteLine("I'm in state one!");
goto case State.One;
}
}

je suis sûr que vous pouvez voir qu'avec cette instruction goto une fois que le programme entre dans ce bloc de code, il ne va pas le quitter ;)

OK, c'est tout pour aujourd'hui , et j'espère bien que cet Article était utile , au moins pour les gens qui ne savaient pas les possibilités de Saut entre les blocs case en c#

Google ajoute un outil analytique au service blogger

2010-09-05T01:02:00.010+01:00

le service d'hébergement et de publication de blogs Blogger a maintenant sa propre fonctionnalité d'analyse qui surveille l'utilisation d'un blog a travers des rapport détaillés et des graphes ( beaucoup similaire a Google Analytics).

et parce que les statistiques sont une fonctionnalité native de blogger , les éditeurs n'ont pas a faire quelque chose de spécial pour les activer , il suffit de vérifier le nouvel onglet statistiques dans le tableau de bord du blog .

avec cette nouvelle fonctionnalité(outil d'analyse des visiteurs blogger) les éditeurs ne sont pas obligé d' intégrer d'autres trackers d'utilisation comme Google Analitics ou autre chose similaire ,Toutefois, l'intégration des outils d'analyse des sites et blogs exige généralement que les éditeurs collent le code dans leurs pages Web ou ajoutent des applications gadget.

Syndication avec C# (rss avec c# 3.5)

2010-08-30T15:13:00.013+01:00

en .Net 3.5 il y a l'espace de nom Syndication qui gère a la fois les Flux RSS et Atom .
Voici un extrait de code d'un petit lecteur de Flux RSS/Atom ,pour le moment c'est une petite application Console , mais je vais essayer de publier une version WPF dans les prochains jours nchalah .
A première vue c'est très facile a implémenter , Il suffit juste d'ajouter System.ServiceModel et System.ServiceModel.Web comme référence à votre projet et commencer a coder votre lecteur de syndication ;)

using System;
using System.ServiceModel.Syndication;
using System.Xml;

namespace rsstest
{
class Program
{
static void Main(string[] args)
{
try
{

XmlReader reader = XmlReader.Create("http://ch-zaki.blogspot.com/feeds/posts/default");
SyndicationFeed feed = SyndicationFeed.Load(reader);
foreach (SyndicationItem item in feed.Items)
{
Console.WriteLine(item.LastUpdatedTime.DateTime.ToString() +" : " +item.Title.Text);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadLine();
}
}
}

et voila le resultat de l'exemple l'execution :

Microsoft .net Remoting

2010-05-14T08:41:00.024+01:00

SOMMAIRE:

Qu’est-ce qu’un système/Application Distribuée
C’est quoi.net Remoting?
Architecture.Net Remoting
Les Objets en .NET Remoting
Exemple Illustratif (Étapes de Développement)
Conclusion

I-Qu’est-ce qu’un système/Application Distribuée :

Système Distribué: c’est système composé d’un ensemble de processus faiblement couplés
connectés par un réseau de communication.

Application distribuée:Application qui suit les principes de l'architecture client-serveur, et peut tourner de façon transparente sur plusieurs ordinateurs reliés en réseau.

II-C’est quoi.net Remoting?

*.Net Remoting est une technologie Microsoft permettant l’implémentation d’applications distribuées , elle est comparable a RMI de java.

*Offre une structure riche et extensible permettant à des objets existant dans différents domaines d'applications, différents processus et sur différentes machines de communiquer sans problème.

*Propose un modèle de programmation à la fois très simple et puissant ainsi q' une prise en charge Runtime rendant ces interactions transparentes (Abstraction de la notion de sockets).

*Le principe général de .Net Remoting est d'exposer sur une partie serveur des objets accessibles par des clients distants en utilisantdes Différent protocoles tel que TCP/Binaire et http/Soap.

III-Architecture.Net Remoting:

Dans une architecture Remoting on trouve principalement:

Serveur:il s’agira de l’application qui héberge l’objet distribué.

Client:il s'agira de l’application qui appellera à distance l'objet Distribué situé sur le serveur.

L'interface:elle contiendra la déclaration des méthodes de l'objet distribué.

Le proxy : c’est une couche intermédiaire créée Dynamiquement par le framework et qui se
charge du routage des demandes du client vers le serveur sur le réseau et inversement de récupérer les réponses du serveur. Donc, lorsque on Réalise des appels distants, on ne dialogue pas directement avec le serveur mais avec le proxy

IV-Les Objets .NET Remoting:

-En .Net Remoting Les objets ou leur référence pourront transiter via le réseau grâce au principe du marshalling (empaquetage).

-Les protocoles et formatages possibles sont paramétrables : TCP+Binaire ou Http+Soap par exemple.

-Par défaut, le framework .NET propose Tcpet Http, mais la technologie .NET Remoting permet à des éditeurs tiers de réaliser leurs propres implémentations et rend donc .NET Remoting potentiellement ouvert.

-En remoting, on ne peut communiquer que des objets dits "Serialisables". Autrement dit, ceux qui implémentent l'interface ISerializable.

-La sérialisation est le processus qui permet de transformer l'objet en un format commun, et communicable sur le réseau.

*On peut "servir" (dans le sens publier, mettre à la disponibilité des clients) un objet de deux façons possibles: -Par référence (MarshallByRef) ou (MBR)
-Par valeur (MarshallByValue) ou (MBV)

1-Par référence (MarshallByRef):Les objets vivent sur le serveur, et le client utilise une référence à ces objets. On peut comparer ça à un pointeur sur une variable mais sur le réseau.

2-Par valeur (MarshallByValue): Le client manipule une copie de l'objet qui est sur le serveur. les Clients et serveur ont chacun leur copie et l'utilisent indépendamment.

-Modes D’activation des Objets en .net Remoting
En .NET Remotingon parle plutôt d’activation d’objets que de création d’objets car la création génère l’activation de plusieurs actions avant la disponibilité effective de l’objet.
Il existe trois types d’activation d'objets distants (deux Coté Serveur, et une Coté Client) ,on peut opter pour l'un ou l'autre
en fonction des besoins de Notre application:
Coté Serveur:
-Single call
-Singleton

Coté Client:
-Client Activated Object (CAO)

Mode SingleCall(Activation Coté Serveur):Dans ce mode à chaque appel, le serveur crée une nouvelle instance de l'objet qui est détruit après chaque utilisation.

Mode Singleton(Activation Coté Serveur):
Un seul objet est partagé entre les clients et les appels pendant une durée de vie fixée.Lorsquecette derniereest expirée, l'objet est réinstancié.

CAO (Activation Coté Client):
Dans ce mode l’objet est Activé par le Client = une instance par client
L’instance de l’objet est créée dès l’appel a Activator.CreateInstance() du client.

V Exemple illustratif:

-Les Etapes de Developpementd’une Application d’une .Net Remoting
Dans cet Exemple on va essayer de donner un exemple d’une petite Application Remoting, dont le Serveur offre un Service de Mise En Majuscule

Les Elementsde base:
Une Application Remotingest Composée princialementde:
Une Interface,un Client,et un Serveur

1-Definition de l’interface:Pour que le client ait connaissance des méthodes distantes, une interface contenant leur déclaration doit être distribuée côtéclient et côté serveur. L'objet exposé sur le serveur devra implémenter cette interface.Cette interface sera Donc le seul élément commun entre le serveur et le client

namespace Interface
{
public interface IService
{
string MettreEnMajuscule(string ClientMessage);
}
}

2-Le Serveur:du côté serveur L'objet Distribué exposé sur le serveur devra implémenter MarshalByRefObject,etL’interface du Service Définie Precedement(Iservice).

class Service:MarshalByRefObject,Interface.IService
{
public string MettreEnMajuscule(string ClientMessage)
{
Console.WriteLine("Le serveur a recu la chaine:{0}",ClientMessage);
return ClientMessage.ToUpper();
}

}

on implémente la classe MarshalByRefObject qui indique que le client ne contiendra qu'une référence de l'objet et non l'objet lui-même, une sorte de pointeur de fonction distant. Ce fonctionnement est à opposer à MarshalByValue où une copie complète d'un objet sérialisableest passée au client.

Configuration et lancement du serveur
-Création et Enregistrement d'un nouveau Canal d’Ecoute
-Démarrage de l'écoute en exposant l'objet dans le mode Souhaité

class Program
{
static void Main(string[] args)
{
try
{
TcpChannel channel = new TcpChannel(12345);//creation du canal
ChannelServices.RegisterChannel(channel);//enregistrement du canal

//Exposition de l'objet et demarrage d'ecoute
RemotingConfiguration.RegisterWellKnownServiceType(typeof(Service), "MiseEnMajuscule", WellKnownObjectMode.Singleton);
Console.WriteLine("Serveur en Marche...");
}
catch (Exception ex) { Console.WriteLine(ex.Message); }
finally
{
Console.ReadLine();
}

Ici, nous Avons Creéun nouveau canal(Channel) de type Tcp. Des channels d'autres types pourraient être utilisés comme HttpChannel ou des développements non standards comme IIOPChannel. TcpChannel a l'avantage ici d'être plus rapide que HttpChannel puisque les données transitent en binaire.
-La Configuration peut etreaussi faite a l’aide de la methode.Configure() qui utilse un fichier XML pour charger la configuration
-Cette Alternative est tres utile car on n’est pas obligé de Recompiler le Serveur a chaque fois qu’on desire changer la configuration(Numerode port,Objéexposé,Moded’Exposition…)

3-Le Client:
-Ajouter une reference de l’interface de l’objet distribuéde distribué

-Créer un Canal de communication (Le meme type du canal/Formattage que le Serveur utilise)

-Recuperer la la Reference de l’objet distantde

-Utilisation de la Reference…

static class Program
{

static void Main()
{
Interface.IService RemoteService;
TcpChannel channel = new TcpChannel();
ChannelServices.RegisterChannel(channel);
RemoteService = (Interface.IService)Activator.GetObject(typeof(Interface.IService), "Tcp://127.0.0.1:12345/MiseEnMajuscule");
while (true)
{
Console.WriteLine(RemoteService.MettreEnMajuscule(Console.ReadLine()));
}
}
}

Conclusion

Le .NETRemoting est la dernière technologie en matière d'applications distribuées, Dans le domaine des applications client- serveur, il y a eu une constante évolution. Parmi les "anciens" concepts on peut citer CORBA, COM+, Java RMI ou plus dernièrement les Web Services.
-.NET Remoting est une technologie intéressante pour les applications qui requièrent un couplage fort.C'est-à-dire pour des appels distants qui permettent de disposer de transactions, de levées d'exceptions, et autres principes applicatifs que l'on retrouve dans des développements non distribués, plus conventionnels. Avec le protocole TCP et une communication en binaire, le transport est également plus rapide.

telecharger cet Article sou format Power point : ICI
télécharger l'exemple illustratif: ICI

Caml

2010-04-21T15:52:00.000+01:00

Programmation fonctionnelle :

La programmation fonctionnelle est un paradigme de programmation qui considère le calcul en tant qu'évaluation de fonctions mathématiques et rejette le changement d'état et la mutation des données. Elle souligne l'application des fonctions, contrairement au modèle de programmation impérative qui met en avant les changements d'état^[1].
Un langage fonctionnel est donc un langage de programmation dont la syntaxe et les caractéristiques encouragent la programmation fonctionnelle. Alors que l'origine de la programmation fonctionnelle peut être trouvée dans le lambda-calcul, le langage fonctionnel le plus ancien est Lisp, créé en 1958 par McCarthy. Lisp a donné naissance à des variantes telles que Scheme (1975) et Common Lisp (1984)^[2], qui comme Lisp ne sont pas ou peu typés. Des langages fonctionnels plus récents tels ML (1973), Haskell (1987), OCaml, Erlang, Clean et Oz, CDuce (2003) ou F# sont fortement typés.

Programmation fonctionnelle

La programmation fonctionnelle s'affranchit de façon radicale des effets secondaires en interdisant toute opération d'affectation.
Le paradigme fonctionnel n'utilise pas de machine d'états pour décrire un programme, mais un emboîtement de fonctions que l'on peut voir comme des « boîtes noires » que l'on peut imbriquer les unes dans les autres. Chaque boîte possédant plusieurs paramètres en entrée mais une seule sortie, elle ne peut sortir qu'une seule valeur possible pour chaque n-uplet de valeurs présentées en entrée. Ainsi, les fonctions n'introduisent pas d'effets de bord. Un programme est donc une application, au sens mathématique, qui ne donne qu'un seul résultat pour chaque ensemble de valeurs en entrée. Cette façon de penser, qui est très différente de la pensée habituelle en programmation impérative est l'une des causes principales de la difficulté qu'ont les programmeurs formés aux langages impératifs pour aborder la programmation fonctionnelle. Cependant, elle ne pose généralement pas de difficultés particulières aux débutants qui n'ont jamais été exposés à des langages impératifs. Un avantage important des fonctions sans effet de bord est la facilité que l'on a à les tester unitairement. Par ailleurs, l'usage généralisé d'une gestion de mémoire automatique par l'intermédiaire d'un ramasse-miettes (en anglais garbage collector) simplifie la tâche du programmeur.
En pratique, pour des raisons d'efficacité, et du fait que certains algorithmes s'expriment aisément avec une machine d'états, certains langages fonctionnels autorisent la programmation impérative en permettant de spécifier que certaines variables sont assignables (ou mutables selon la dénomination habituelle), et donc la possibilité d'introduire localement des effets de bord. Ces langages sont regroupés sous le nom de langages fonctionnels impurs.
Les langages dits purement fonctionnels n'autorisent pas la programmation impérative. De fait, ils sont dénués d'effets de bord et protégés contre les problèmes que pose l'exécution concurrente. On peut voir par exemple ce qui a été fait dans le cadre du langage Erlang.
L'implémentation des langages fonctionnels fait un usage sophistiqué de la pile car afin de s'affranchir de la nécessité de stocker des données temporaires dans des tableaux ils font largement appel à la récursivité (fait d'inclure l'appel d'une fonction dans sa propre définition). La récursivité peut être rendue plus efficace à l'aide d'une technique dénommée récursion terminale (en anglais tail-recursion), qui consiste à accumuler les résultats intermédiaires dans une case mémoire de la pile et à la passer en paramètre dans l'appel récursif. Ceci permet d'éviter d'empiler les appels récursifs dans la pile en les remplaçant par une simple succession de sauts. Le code généré par le compilateur est alors similaire à celui généré par une boucle en impératif. Certains langages comme Scheme, OCaml et Anubis optimisent automatiquement les appels récursifs de cette manière.

le langage Caml:

Caml (originalement acronyme de Categorical Abstract Machine Language) , (un jeu de mots sur "La machine abstraite catégorique" et "ML" la famille des langages a laquelle il appartient .

Caml a été conçu et mis en œuvre dans le projet Formel à l'INRIA Dirigé par "Gerrard Huet" jusqu'au 1994 et maintenant son developpement se poursuit dans le projet "Cristal".

Comme tous les descendants de ML, Caml est typé statiquement, rigoureusement évalués, et utilise la gestion automatique de la mémoire.
la première implémentation de Caml en Lisp a été surnommée :"Heavy CAML" en raison de ses exigences Mémoire et CPU , par Rapport a son successeur "CAML Light" qui a été implémente en C par "Xavier Leroy" et " Damien Doligez" . en plus de sa réécriture complète "Caml Lihgt" a ajouter un puissant système de modules pour le noyeau du langage .

Actuellement l'implémentation principale de "Caml" est "Objective Caml", qui ajoute de nombreuses nouvelles fonctionnalités pour les langues, y compris une couche objet.

Caractéristiques et fonctionnalités du langage

Sûreté:

Le langage Caml est très sûr. Le compilateur fait de nombreuses vérifications avant la compilation des programmes. De nombreuses erreurs de programmation deviennent ainsi impossibles en Caml: confusions de types de données, accès erronés à l'intérieur des données par exemple. En effet, tous ces points sont vérifiés et gérés automatiquement par le compilateur, ce qui garantit l'intégrité parfaite des données manipulées par les programmes.
Caml est typé statiquement, mais il est inutile d'ajouter des informations de type dans les programmes (comme en Ada, en Pascal ou en C): les annotations de typage sont automatiquement calculées par le compilateur.
Types de données:

Il existe en Caml de nombreux types de données prédéfinis:

types de base: entiers, flottants, booléens, caractères, chaînes de caractères.
types de données plus complexes: n-uplets, tableaux, listes, ensembles, tables de hachage, files, piles, flux de données.

Au-delà de ces types prédéfinis, Caml propose de puissants moyens de définir de nouveaux types: types enregistrements, types énumérés, et types sommes généraux. Les types sommes sont une généralisation des types unions, à la fois simple, sûre et facile à maîtriser. Ils permettent la définition de types de données qui présentent des valeurs hétérogènes repérées par des constructeurs de valeurs.
Au gré du programmeur, tous ces types sont définissables concrètement (les constructeurs sont disponibles à l'extérieur du module) ou abstraitement (l'implémentation est restreinte au module de définition et les constructeurs sont invisibles à l'extérieur).
Ce mécanisme autorise un contrôle fin du degré d'encapsulation des données manipulées par les programmes, ce qui est indispensable pour la programmation à grande échelle.
Fonctions:
Caml est un langage de programmation fonctionnel: il n'y a pas de restriction à la définition et à l'usage des fonctions, qu'on peut librement passer en argument ou retourner en résultat dans les programmes.

Gestion mémoire automatisée et incrémentale:

Caml offre une gestion automatique de la mémoire: l'allocation et la libération des structures de données est implicite (il n'y a pas de primitives de manipulation explicite de la mémoire comme ``new'' ou ``free'' ou ``dispose''), et laissée à la charge du compilateur. On obtient ainsi une programmation bien plus sûre, puisqu'il n'y a jamais de corruption inattendue des structures de données manipulées.
De plus le gestionnaire mémoire opère en parallèle avec l'application, sans jamais l'arrêter de façon notable (récupération mémoire incrémentale).

Traits impératifs:

Caml offre la panoplie complète des traits de la programmation impérative, en particulier les tableaux modifiables en place, les boucles et les variables affectables, les enregistrements avec champs physiquement modifiables.

Compilateur rapide, code exécutable rapide:

Caml propose un compilateur de fichiers, et la compilation séparée est assurée par un système de modules. De surcroît, le compilateur Caml comporte une option qui maximise la vitesse de compilation, la portabilité des programmes obtenus, et minimise la taille des exécutables (compilation en code-octets).
Le compilateur d'Objective Caml comporte en plus une option ``optimisante'' qui privilégie la vitesse d'exécution (compilation en code natif): le compilateur optimisant d'Objective Caml produit des programmes dont la vitesse d'exécution est digne des meilleurs compilateurs disponibles actuellement.

Interactivité

Caml offre également un système interactif (une boucle de lecture-évaluation-impression des résultats), qui est très pratique pour apprendre le langage ou essayer et corriger ses programmes: il n'y a pas besoin d'utiliser forcément des fichiers, ni d'ajouter des ordres d'impression dans les programmes puisque les résultats sont imprimés automatiquement par le système interactif.

Forte capacité de traitement symbolique

Caml vous propose la ``programmation orientée par filtrage'': cette puissante méthode de programmation est une généralisation de l'analyse de cas traditionnelle qui est maintenant disponible pour tous les types de données du langage. Le mécanisme de filtrage est un moyen concis et élégant de ``tester et de nommer'' les données en une seule opération. Le compilateur Caml tire avantage de ce trait unique pour faire de nombreuses vérifications sémantiques sur le code qui lui est soumis: le vérificateur de filtrage du compilateur est capable de détecter les branches inutiles des analyses de cas (``ce cas ne se présentera jamais à l'exécution'') et, plus étonnant encore, de détecter les cas oubliés (``ce cas n'est pas envisagé par votre programme''). Ainsi, le vérificateur de filtrage met souvent le doigt sur de subtiles erreurs qui se glissent dans les programmes. De surcroît, le vérificateur de filtrage est capable d'apporter la preuve de couverture exhaustive des cas des programmes qui utilisent le filtrage.
Le filtrage apporte un confort inégalé dans le traitement symbolique des données.
Le vérificateur de filtrage procure un niveau de sécurité dans la programmation et un degré de qualité inégalé des programmes qui manipulent des données symboliques.

Traitement des erreurs:

Caml possède un mécanisme général d'exceptions, pour traiter ou corriger les erreurs ou les situations exceptionnelles.
Mise au point des programmes
Plusieurs méthodes de mise au point des programmes s'offrent à vous en Caml:

le système interactif offre une méthode élémentaire mais très simple et rapide pour tester des (petites) fonctions: on vérifie simplement les résultats obtenus sur quelques exemples tapés directement dans la boucle d'interaction.
dans les cas plus complexes, le système interactif permet également à très peu de frais de suivre la progression des calculs avec le mécanisme de trace des appels de fonctions.
enfin le debogueur symbolique avec retour arrière permet de suivre très finement le déroulement de l'exécution, de l'arrêter à tout moment pour examiner l'état courant des variables et des fonctions en attente, et même de revenir en arrière dans les calculs pour reprendre l'exécution au moment où un evênement intéressant se produit.

Polymorphisme

Caml est doté d'un puissant typage ``polymorphe'': certains types peuvent rester indéterminés, représentant alors ``n'importe quel type''.
Ainsi, les fonctions et procédures qui sont d'usage général s'appliquent à n'importe quel type de données, sans exception (par exemple les routines de tri s'appliquent à tout type de tableaux).

Méthode d'évaluation

Caml est un langage ``strict'', par opposition aux langages paresseux. Cependant la pleine fonctionnalité permet de créer des suspensions et donc de coder l'évaluation paresseuse de données potentiellement infinies.

Programmation en vraie grandeur

Les programmes Caml sont formés d'unités de compilation que le compilateur compile séparément. Ces organisation est parfaitement compatible avec l'utilisation d'outils traditionnels de gestion de projets (comme l'utilitaire make d'Unix). Le système de module du langage est puissant et sûr (toutes les interactions entre modules sont statiquement vérifiées par le contrôleur de types). Les modules d'Objective Caml peuvent comporter des sous-modules (à un degré d'emboîtement quelconque) et les fonctions des modules dans les modules sont autorisées (ce qui permet de définir des modules paramétrés par d'autres modules).

Programmation orientée objets

Objective Caml propose des objets qui permettent d'utiliser le style orienté objets dans les programmes Caml. Fidèle à la philosohie du langage, cette extension orientée objets obéit au paradigme du ``typage fort'': en conséquence, aucune méthode ne peut être appliquée à un objet qui ne pourrait y «répondre» («les méthodes sont toujours bien comprises»). Encore une fois, cette vérification systématique du compilateur évite de nombreuses erreurs. Ceci offre au programmeur Caml, outre un confort insoupçonné dans l'écriture de ses programmes orientés objets, un niveau inégalé de qualité des programmes qu'il produit.

Puissantes bibliothèques

De nombreuses bibliothèques et contributions sont disponibles en Caml, en particulier des primitives de dessin indépendantes de la machine (libgraph), une arithmétique rationnelle exacte en multi-précision (camlnum), et de nombreuses interfaces avec des technologies bien connues: générateurs d'analyseurs lexicaux et syntaxiques avec camllex et camlyacc. Sous Unix, on dispose aussi d'un débogueur avec retour arrière, d'un navigateur dans les fichiers sources (camlbrowser), d'une interface graphique à l'aide de Tk/Tcl (camltk) et d'une interface poussée avec le système (libunix).

Examples de code:

1-Fonction factorielle (récursivité et la programmation purement fonctionnel):

 let rec fact n = if n=0 then 1 else n * fact(n-1);;

2-Dérivés numeriques (fonctions d'ordre supérieur):
en tant que langage de programmation fonctionnelle, il est facile de créer et passer autour
des fonctions dans les programmes OCaml.
Cette capacité a un très grand nombre d'applications. Calcul de la dérivée numérique
d'une fonction est une telle demande. La fonction Caml suivant:
"d" calcule la dérivée numérique d'une fonction donnée "f" à un moment donné "X":

 let d delta f x =
     (f (x +. delta) -. f (x -. delta)) /. (2. *. delta);;

dangling pointers(pointeurs ballants)

2010-01-18T15:19:00.010+01:00

dangling pointers en programmation sont des pointeurs qui ne pointent pas vers un objet valide du type approprié.ils sont survenus lorsque un objet est supprimé ou désalloué sans modifier la valeur des pointeurs qui pointent cet objet. alors que le pointeur pointe toujours vers l'emplacement mémoire désalloué. et le Système peut réaffecter l'espace mémoire précedement liberer un a autre processus.
dans ce cas si le programme d'origine déreference le pointeur un comportement imprévisible peut se produire.
c'est le meme cas ou le programme ecrit les données dans la zone mémoire pointée par le dangling pointer,une corruption silencieuse des données non-liés peut se produire conduisant a des bogues subtiles extrêmement difficile à les détecter , des erruers de segmentation ou des defauts de protection générals(sous Windows).
Si les Données écrasées sont des données de compatibilité utilisé par allocataire mémoire du Système la corruption peut causer des instabilités de ce dernier.

Les Causes des dangling pointers:
dans beaucoup de languages de programmation(language C par exemple) la suppression d'un objet a partir de la mémoire de maniere explicite ou implicite ne modifie pas les pas les pointeurs associés.le pointeur point toujours vers le meme emplacement mémoire meme si la reference a été supprimé et peut etre maintenant utilisés par d'autres processus.
Exemple:



char *dp=NULL;

/*...*/
{
char c;

/* c maintenant est hors porté */

dp=&c; /* dp est un dangling pointer */

Resoudre le Probleme de Dangling pointer

une Solution pour resoudre ce qui précède est d'attribuer la valeur NULL a dp immédiatement avant que le bloc interne est quitté .
une autre solution serait de garantir que dp ne serait pas utilisé a nouveau sans initialisation supplementaire.

-une autre source fréquente de ce probleme (dangling pointers)est une combinaison confuse des appels malloc( ) et free( ) , un pointeur devient ballant lorseque le bloc mémoire pointé est libéré. une façon d'éviter cela est de s'assurer de réinitialiser le pointeur a NULL apres la liberation de sa reference.
Exemple:





{



char *dp=malloc(A_const);



/*........*/



free(dp); /* il devient un pointeur ballant */



dp=NULL ; /*maintenant il n'est plus ballant*/



/*........*/



}

Chat client serveur avec c#

2009-06-02T16:38:00.008+01:00

voici une petite application de chat client/ serveur avec c#
l'application est très légère et ne contient pas beaucoup de code

serveur:

client:

j'ai pas pu maitre tous le code dans le blog mais vous vouvez le telecharger ici

analyseur lexical pascal (en c)

2009-02-05T18:12:00.023+01:00

Voici un Analyseur lexical pour les programmes en langage Pascal , il est programmé en C dans le Cadre d'un TP du module Compilation

Telecharger(avec le code source)

Probleme avec le lien ? telecharger le depuis CPPfrance.com