Facebook RSS Feed
 
.NET Micro Framework: JSON Oluşturmak
Tarih: 27.09.2014, Platform: .NET MF 4.3, IDE: Visual Studio 2013, Level: 200

Internet of Things'in hızla yaygınlaştığı günlerde, cihazlar arası veri transferi gittikçe önem kazanıyor. Örneğin, bir sensör uçbiriminden aldığımız verinin hafıza kartına kaydedilmesi ya da web servisine iletilmesi gibi senaryolar daha sık karşımıza çıkıyor. Elbette bu senaryolarda veriyi optimize biçimde transfer etmemiz işlemci, güç ve veri kullanımında projelerimize olumlu katkılarda bulunacak.

JSON, objelerin kolay okunabilir ve işlenebilir yapıda saklanmasında ön plana çıkan biçimlerden biri. XML'e göre daha az yer kaplar ve işlenirken mikrodenetleyicinin daha az kaynak tüketmesine yardımcı olur. Öyleyse, Internet cihazlarının iletişimi için harika bir çözüm olan JSON yapısına bir göz atalım.

{"Temperature": "34", "Humidity": "56"}

Bu kadar! Isı ve nem değerlerini içeren bir JSON yapısı, son derece okunabilir ve işlenebilir olarak karşımızda. Elbette JSON ile karmaşık yapılar oluşturmak mümkün. Fakat mikroişlemci üzerinde işlem yaptığımızı unutmadan, kullandığımız verilerin de olabildiğince mikro olmasına özen göstermeliyiz.

JSON yapısını temel olarak biliyoruz. Şimdi verilerimizi JSON’a dönüştüren bir uygulama üzerinde duralım.

Uygulama Kodları

Visual Studio üzerinde oluşturacağımız “JSONTest” adlı .NET Micro Framework Console Application projesine, JSON adında bir klasör açalım. Bu klasörün içine 3 class ekleyeceğiz.

[C#] JSON\Json.cs

using System;
using System.Reflection;

namespace JSONTest.JSON
{
    /// <summary>
    /// This static class contains a method to convert a value to its JSON equivalent.
    /// Programmed by Huysentruit Wouter
    /// </summary>
    public static class Json
    {
        /// <summary>
        /// Lookup table for hex values.
        /// </summary>
        private const string HEX_CHARS = "0123456789ABCDEF";
        public const string ContentType = "application/json";

        /// <summary>
        /// Converts a character to its javascript unicode equivalent.
        /// </summary>
        /// <param name="s">The character to convert.</param>
        /// <returns>The javascript unicode equivalent.</returns>
        private static string JsUnicode(char c)
        {
            string result = "\\u";
            ushort value = (ushort)c;

            for (int i = 0; i < 4; i++, value <<= 4)
                result += HEX_CHARS[value >> 12];

            return result;
        }

        /// <summary>
        /// Encodes a javascript string.
        /// </summary>
        /// <param name="s">The string to encode.</param>
        /// <returns>The encoded string.</returns>
        private static string JsEncode(string s)
        {
            string result = "";

            foreach (char c in s)
            {
                if (c < (char)127)
                {
                    switch (c)
                    {
                        case '\b': result += "\\b"; break;
                        case '\t': result += "\\t"; break;
                        case '\n': result += "\\n"; break;
                        case '\f': result += "\\f"; break;
                        case '\r': result += "\\r"; break;
                        case '"': result += "\\\""; break;
                        case '/': result += "\\/"; break;
                        case '\\': result += "\\\\"; break;
                        default:
                            if (c < ' ')
                                result += JsUnicode(c);
                            else
                                result += c;
                            break;
                    }
                }
                else
                    result += JsUnicode(c);
            }

            return result;
        }

        /// <summary>
        /// Convert a value to JSON.
        /// </summary>
        /// <param name="o">The value to convert. Supported types are:
        /// Boolean, String, Byte, (U)Int16, (U)Int32, Float, Double, Decimal,
        /// JsonObject, JsonArray, Array, Object and null.</param>
        /// <returns>The JSON object as a string or null when the value type is not supported.</returns>
        /// <remarks>For objects, only public fields are converted.</remarks>
        public static string ToJson(object o)
        {
            if (o == null)
                return "null";

            Type type = o.GetType();
            switch (type.Name)
            {
                case "Boolean":
                    return (bool)o ? "true" : "false";
                case "String":
                    return "\"" + JsEncode((string)o) + "\"";
                case "Byte":
                case "Int16":
                case "UInt16":
                case "Int32":
                case "UInt32":
                case "Single":
                case "Double":
                case "Decimal":
                case "JsonObject":
                case "JsonArray":
                    return o.ToString();
            }

            if (type.IsArray)
            {
                JsonArray jsonArray = new JsonArray();
                foreach (object i in (Array)o)
                    jsonArray.Add(i);
                return jsonArray.ToString();
            }

            if (type.IsClass)
            {
                JsonObject jsonObject = new JsonObject();
                foreach (FieldInfo info in type.GetFields())
                    jsonObject.Add(info.Name, info.GetValue(o));
                return jsonObject.ToString();
            }

            return null;
        }
    }
}

[C#] JSON\JsonArray.cs

using System.Collections;

namespace JSONTest.JSON
{
    /// <summary>
    /// A Json Array.
    /// Programmed by Huysentruit Wouter
    /// 
    /// Supported value types are those supported by the Json.ToJson method.
    /// See the Json.ToJson method for more information.
    /// </summary>
    public class JsonArray : ArrayList
    {
        /// <summary>
        /// Convert the array to its JSON representation.
        /// </summary>
        /// <returns>A string containing the JSON representation of the array.</returns>
        public override string ToString()
        {
            string[] parts = new string[Count];

            for (int i = 0; i < Count; i++)
                parts[i] = Json.ToJson(this[i]);

            string result = "";

            foreach (string part in parts)
            {
                if (result.Length > 0)
                    result += ", ";

                result += part;
            }

            return "[" + result + "]";
        }
    }
}

[CS] JSON\JsonObject.cs

using System.Collections;

namespace JSONTest.JSON
{
    /// <summary>
    /// A Json Object.
    /// Programmed by Huysentruit Wouter
    /// 
    /// Keys must be strings!
    /// Supported value types are those supported by the Json.ToJson method.
    /// See the Json.ToJson method for more information.
    /// </summary>
    public class JsonObject : Hashtable
    {
        /// <summary>
        /// Convert the object to its JSON representation.
        /// </summary>
        /// <returns>A string containing the JSON representation of the object.</returns>
        public override string ToString()
        {
            string result = "";

            string[] keys = new string[Count];
            object[] values = new object[Count];

            Keys.CopyTo(keys, 0);
            Values.CopyTo(values, 0);
            
            for (int i = 0; i < Count; i++)
            {
                if (result.Length > 0)
                    result += ", ";

                string value = Json.ToJson(values[i]);
                if (value == null)
                    continue;
                
                result += "\"" + keys[i] + "\"";
                result += ": ";
                result += value;
            }

            return "{" + result + "}";
        }
    }
}

Bu class’ları ekledikten sonra, uygulamamız kolay bir şekilde JSON çevirisini yapmaya hazır hale geliyor. Uygulamamızın ana dosyasına gerekli eklemeleri yaparak JSON’ı oluşturacağız.

[C#] Program.cs

using System;
using Microsoft.SPOT;
using JSONTest.JSON;

namespace JSONTest
{
    public class Program
    {
        public static void Main()
        {
            // JSON Objesi oluşturalım:
            JsonObject jo = new JsonObject();

            // Verileri ekleyelim:
            jo.Add("Temperature", 25.2);
            jo.Add("Humidity", 50.5);

            // JSON Cümlesini yazdıralım:
            Debug.Print(jo.ToString());
            // Okuyacağımız satır: {"Temperature": 25.2, "Humidity": 50.5}

            //Uygulamayı uyutalım:
            System.Threading.Thread.Sleep(-1);
        }
    }
}

Uygulamayı çalıştırdığınızda, VS Immediate Window’da (ya da Output) {"Temperature": 25.2, "Humidity": 50.5} satırını göreceksiniz. Bir sonraki yazımızda bu JSON verisini HTTP Post Request ile İnternet’e göndermeyi ele alacağız.


Ek Dosya: Belirtilmemiş.
Okunma Sayısı: 1606

comments powered by Disqus
 
Hoşgeldiniz!
Son güncelleme: 25.12.2016
-
Yeni Teknik Yazılar
Latte Panda İncelemesi
Turta IoT HAT İncelemesi
USB Gamepad Kullanımı
GPIO Kullanımı
VEML6075 UV Sensör Kullan...
-
İlgili Gruplar
.NET MF ve Gadgeteer FB Grubu
İst. IoT & Wearables Meet-up
-
 

This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License.Copyright © 1999 - 2017, Umut Erkal. Bu materyal, "Creative Commons Public Licence" ile sunulmuştur.
Kaynak göstererek ve ücretsiz olarak, aynı şartlar altında paylaşabilir ve kullanabilirsiniz. | Kullanım Sözleşmesi