Articles tagués .net

JsConsole.Net– Console javascript déportée pour le déboggage

J’ai développé cette petite application Windows pour me permettre lors du débogage d’applications web, de visualiser la console JavaScript de manière déportée. Sur certains devices, comme la plupart des consoles de jeux, il n’est pas possible d’accéder à cette console de débogage.

L’application a été développée en C# et WPF  pour l’interface utilisateur et utilise le pattern MVVM indispensable au découpage fonctionnel du code.
Concernant les fonctionnalités un serveur web Owin permet l’auto hébergement des applications web au sein du répertoire « /Web » qui se trouve a la racine de l’application. Par contre, Owin nécessite une élévation de privilège pour ouvrir des sockets réseaux au niveau d’une IP externe, l’application lors de l’exécution vous demandera donc une autorisation plus élevée lors du lancement.
Il est possible aussi d’écrire des bouts de codes « snippet » en créant des fichiers avec l’extension js dans le répertoire « /snippet » ceux-ci pourront être directement inséré dans la console d’exécution des scripts.
Le but de cette application était aussi  pour moi, de mettre en pratique certains frameworks comme l’association entre AngularJs et SignalR.
Par la suite, j’ai inclus une fonctionnalité d’intelliSence lorsque l’on tape du code JavaScript, ce qui m’a semblé bien pratique pour un développeur. Pour cela, la bibliothèque la plus aboutie est AvalonEdit, malheureusement celle-ci n’est pas compatible avec MVVM. Il faut donc faire un peu de code dans la partie code behind, je n’aime pas trop, mais je pense que dans une prochaine version j’essayerai de la rendre compatible MVVM, soit en créant une classe qui hérite des classes d’avalonEdit ou un behavior ou encore avec une attached propertie.

Ce projet a été développé avec les librairies suivantes
–    AvalonEdit
–    MahApps
–    Owin
–    Mvvm Light Toolkit
–    AngularJS
–    SignalR
–    Bootstrap

Voiçi une vidéo, pour comprendre l’utilisation de l’application :

Le code est disponible ici : https://github.com/auriou/JsConsole.Net

, , ,

Poster un commentaire

FIGlet.Net – Génération et OCR de Textes Art ASCII

Lors d’un challenge informatique qui avait pour but de répondre à un robot sur un canal IRC, j’ai dû développer un programme qui devait reconnaitre des textes aléatoires écrits en Art ASCII en moins d’une seconde et il dévait renvoyer le résultat sur le canal IRC. Cette technique d’écriture de texte était très répandue par le passé sur les mainframes, les BBS, puis sur beaucoup d’applications en mode texte ce qui est encore le cas pour les serveurs IRC.

Une librairie permettant d’écrire ces textes développée en C, existe pour les systèmes Unix . Elle définit un format de fichier de police de caractère. Ce programme est FIGlet et les fichiers de polices ont pour extension .flf .

Mon langage de prédilections étant le C#, j’ai donc développé une version FIGlet.Net et comme j’avais besoin pour ce challenge de lire ce type de texte, j’ai créé une fonction de reconnaissance de caractères des textes Art-ASCII.

Voici un exemple :

artascii

Et le code client, pour utiliser la librairie :

namespace FIGlet.Net
{
    public class SampleClient
    {
        public static void TestUsage()
        {
            var fig = new Figlet(); //font par défaut
            //Chargement d'une font spécifique au format Figlet
            //fig.LoadFont(@"D:\FIGLET\FONTS\standard.flf");

            //Génération et affichage du texte  Art ASCII
            var asciiart = fig.ToAsciiArt("Microsoft.Net");
            Console.WriteLine(asciiart);

            //Préparation d'un alphabet pour la reconnaissance de l'image Art ASCII
            fig.PrepareAlphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.");
            //Reconnaissance de l'image et affichage du texte trouvé
            var reconize = fig.ReconizeAsciiArt(asciiart);
            Console.WriteLine("Résultat OCR-ArtASCII: {0}",reconize);
            Console.ReadLine();
        }
    }
}

J’ai publié le code de ma librairie FIGlet.Net sur GitHub si vous etes intéressé c’est ici :  https://github.com/auriou/FIGlet

, ,

Poster un commentaire

Les patterns de construction dans le framework.Net

Les patterns de construction ont pour rôle de masquer la complexité de création des objets et de rendre le système indépendant du processus d’instanciation des classes. Pour ce faire ces patterns privilégient l’utilisation des Interfaces ou des classes abstraites dans la relation entre les objets en masquant les classes concrètes au client final.

Le choix entre Classe Abstraite et Interface ?

– Choisir une classe abstraite si la classe doit contenir des comportements par défauts, comme par exemple une méthode codée dans la classe abstraite qui pourra être utilisée par l’ensemble des classes concrètes.

– Choisir une interface si toutes les classes concrètes ont leurs propres implémentations.

  • Définition des Patterns de créations :

  1. Abstract Factory : Ce modèle fournit une interface pour créer des familles d’objets liés ou dépendants sans spécifier leurs classes concertes. Créer des objets, de classes abstraites différentes, mais de mêmes familles de classes concrètes. L’abstract factory ne fait rien d’autre que de créer des objets à la différence du pattern Factory Method. Dans ce pattern il faut utiliser un singleton pour n’avoir q’une seule instance de chacune des fabriques concrètes.
  2. Factory Method : Permets de déléguer aux sous-classes l’instanciation au travers d’une méthode abstraite de création des objets. L’appel du constructeur des sous-classe peut être fait en passant un paramètre a la Factory Method. La différence avec Abstract Factory, est que la classe possède d’autres responsabilités que le simple fait de créer des objets.
  3. Singleton : Ce modèle garantit qu’une classe n’a qu’une seule instance et fournit un point d’accès à celle çi.
  4. Builder : Permet d’abstraire la construction d’objets complexe : objets composés – par exemple la fenêtre d’une application composée de différents menus, d’un titre, etc. Sans se soucier par exemple du style de rendu (menu classique, Ruban office …)
  5. Prototype : Il est utilisé pour créer un objet en double ou clone de l’objet courant.
  • Patterns de créations dans le framework.Net :

Voici un exemple de code C# utilisant les 5 types de pattern de conception présent dans le framework.net :

public int DbProviderFactoryPatterns()
{
    // 1 - Abstract Factory : Classes concrètes SQL.. / ODBC.. / OLEDB..
    // Familles de produits : Connection / Command, etc. Commence par CreateXXX
    var dbProviderFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");// 2 - Factory Method

    var dbConnection = dbProviderFactory.CreateConnection();                        // 3 - Factory Method

    var singletonSqlClientFactory = SqlClientFactory.Instance;                      //  4 - Singleton

    if (singletonSqlClientFactory.Equals(dbProviderFactory))
    {
        Console.WriteLine("Provider SQL");
    }

    var connectionStringBuilder = dbProviderFactory.CreateConnectionStringBuilder();//  5 - Builder
    connectionStringBuilder.ConnectionString =                                      //  5 - Builder
        "Data Source=ServerName;Initial Catalog=DatabaseName;Persist Security " +
        "Info=True;Connection Timeout =60;Integrated Security=SSPI";

    dbConnection.ConnectionString = connectionStringBuilder.ConnectionString;

    var dbCommand = dbProviderFactory.CreateCommand();                       // 6 - Factory Method
    dbCommand.CommandType = CommandType.Text;
    dbCommand.CommandText = "select count(*) from Table1";
    dbCommand.Connection = dbConnection;

    if (dbCommand is ICloneable)
    {
        var prototypeDbCommand = (ICloneable)dbCommand;                       // 7 - Prototype
        var dbCommand2 = (DbCommand)prototypeDbCommand.Clone();               // 7 - Prototype
        dbCommand2.CommandText = "select count(*) from Table2";
    }

    try
    {
        dbConnection.Open();
        return dbCommand.ExecuteNonQuery();
    }
    finally
    {
        if (dbConnection.State != System.Data.ConnectionState.Closed)
            dbConnection.Close();
    }
    return -1;        
}

Diagramme UML des classes :

image

  • Abstract Factory : System.Data.Common.DbProviderFactory
Abstraction Fabrique concrète Classe abstraite à créer(famille de produits) Classe concrète à créer(famille de produits) Commentaires
DbProviderFactory SqlClientFactoryOdbcFactory DbCommandDbConnection OdbcCommand
SqlCommand
OdbcConnection
SqlConnection
Le pattern utilise un singleton pour ne disposer que d’une seule instance des fabriques concrètes pour l’ensemble des clients l’utilisant.Les méthodes CreateXXX sont des Factory Method chargées de créer chacune des familles de produits
  • Factory Method  : System.Data.Common.DbProviderFactories

Dans ce cas la factory method ne respecte pas le pattern avec son abstraction comme nous pourrons le voir dans la classe System.Net.WebRequest, mais grâce au paramètre passé à cette méthode (par réflexion) elle renverra l’instance du singleton d’une des fabriques concrète : SqlClientFactory ou OdbcFactory

  • Singleton  : System.Data.SqlClient.SqlClientFactory.Instance

Les instances uniques de chacune des factory sont créées ici par le constructeur statique de la classe en temps qu’instance de classe : OdbcFactory.Instance et SqlClientFactory.Instance

  • Builder  : System.Data.Common.DBConnectionStringBuilder
Abstraction Monteur concret Classe à monter
DBConnectionStringBuilder SqlConnectionStringBuilder
OdbcConnectionStringBuilder
StringString
  • Prototype  : System.ICloneable
Abstraction Classe à instance unique
ICloneable SqlCommand
OdbcCommand
SqlConnection
OdbcConnction
  • Autre exemples :

Voici d’autres exemples de ces patterns de création dans le framework :

public void WebRequestPatterns()
{
    var uriBuilder = new UriBuilder();                //  8 - Builder
    uriBuilder.Scheme = "http";
    uriBuilder.Host = "www.google.fr";

    var webRequest = WebRequest.Create(uriBuilder.Uri);  // 9 - Factory Method

    var webResponse = webRequest.GetResponse();          // 10 - Factory Method
}
public void XmlPatterns()
{
    var xmlDocument = new XmlDocument();
    xmlDocument.Load("file.xml");
    var xmlNode = xmlDocument.CloneNode(true);          // 11 - Prototype
}

Diagramme UML du pattern Factory Method de WebRequest

image

, , , , , , ,

Poster un commentaire

%d blogueurs aiment cette page :