Archives de la catégorie Visual Studio

Convertir du Json et XML en classes C# fortement typées

Visual studio 2012, offre la possibilité de convertir des données XML ou Json en classe C# fortement typée. Quand l’on doit interagir avec des services REST comme les API de google, il est intéressant de pouvoir utiliser le nom des objets dans son code et ainsi éviter d’utiliser un parser XML ou Json.

Pour que cela fonctionne, il faut être dans un projet utilisant le framework .net 4.5

  1. Copier une source XML ou Json dans le presse-papier (Ctrl+A – Ctrl+C)
    1-convertxml
  2. Se placer dans un fichier de code
    2-convertxml
  3. Ouvrir le menu Edition > Collage spécial > Coller XML sous forme de classes
    3-convertxml
  4. Voilà la classe fortement typée créée
    4-convertxml
  5. Voici une classe d’extension pour simplifier la sérialisation des objets
    using Newtonsoft.Json;
    using System.IO;
    using System.Text;
    using System.Xml.Serialization;
    
    namespace SampleCopyObject
    {
        public static class Deserializer
        {
            //nécessite le package nuget : Json.Net http://james.newtonking.com/json
            public static T DeserializeJson<T>(this string strObject)
            {
                return JsonConvert.DeserializeObject<T>(strObject);
            }
            public static T DeserializeXml<T>(this string strObject)
            {
                var stream = strObject.ToStream();
                var serializer = new XmlSerializer(typeof(T));
                return (T)serializer.Deserialize(stream);
            }
            public static Stream ToStream(this string strObject)
            {
                var byteArray = Encoding.UTF8.GetBytes(strObject);
                return new MemoryStream(byteArray);
            }
        }
    }
  6. Solution de test
    using System.Net;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using SampleCopyObject;
    
    namespace SampleCopyObject.Test
    {
        [TestClass]
        public class UnitTestDeserialiser
        {
            [TestMethod]
            public void TestXml()
            {
                const string xmlFile = "http://www.dreamincode.net/forums/xml.php?showuser=1253";
                var client = new WebClient();
                var strObject = client.DownloadString(xmlFile);
                var result = strObject.DeserializeXml<ipb>();
                Assert.IsNotNull(result);
                Assert.IsNotNull(result.profile);
            }
            [TestMethod]
            public void TestJson()
            {
                const string jsonFile = "http://ajax.googleapis.com/ajax/services/search/web?v=1.0&q=test";
                var client = new WebClient();
                var strObject = client.DownloadString(jsonFile);
                var result = strObject.DeserializeJson<Rootobject>();
                Assert.IsNotNull(result);
                Assert.IsNotNull(result.responseData);
            }
        }
    }

Poster un commentaire

Grouper vos fichiers dans visual studio 2012

Dans un projet WPF, Silverlight ou Window Store (WinRT), si l’on utilise le patron de conception MVVM (Model / Vue / VueModel) nous regrouperons les vues dans un répertoire, le plus souvent nommé Views, elles mêmes composées d’un fichier XAML et d’un fichier CS pour le code behind. Pour chacune de ces vues correspond une classe manipulant le model métier, ces fichiers sont placés dans un autre répertoire appelé ViewModels.

Dans un gros projet, cela devient vite compliqué de jongler dans l’explorateur de solution entre la Vue Xaml et le ViewModel.

Il existe une autre possibilitée pour organiser son code, qui est utilisé dans les exemples du framework PRISM. Ce framework permet d’implémenter le pattern MVVM (Command/Message), simplifie le développement d’applications composites, et prend en charge la navigation. Dans les exemples fournis, le choix a été de placer les vues et les vues-modèles dans des répertoires communs par thème fonctionnel.

Je trouve cette pratique plus intuitive, étant donné que Vue et vues-modèles sont complètement liées. Pour aller plus loin dans ce raisonnement, il serait intéressant de regrouper le vue-modèl sous la vue comme c’est déjà le cas pour le code-behind du fichier XAML.

Une extension de visual studio permet de faire cela très simplement, il s’agit de  VSCommand

  • Résultat des regroupements sous chacune des vues

resultat

  1. Installer l’extension VSCommand
    Extension
  2. Sélectionner les fichiers à regrouper > menu contextuel > choisir le menu Group Items

    MenuGroup
  3. Valider la fenêtre suivante
    WindowSelect
  4. Voila les fichiers groupés sous la vue
    ResultatJoin

Poster un commentaire

%d blogueurs aiment cette page :