Windows data json h

Parse JSON with windows.data.json.h in C

I don’t know how you set up your project, but all of the ‘windows.’ headers
(windows.data.json or windows.data.text) are for applications using the UWP
(Universal …

{"main":"Hello World"}



#include <windows.data.json.h>

int main() {

    JsonObject(Parse("{\"main\":\"Hello World\"}"));

    return 0;
}



``` c

#include <roapi.h>
#include <windows.data.json.h>
#include <stdio.h>

#pragma comment(lib, "kernel32.lib")
#pragma comment(lib, "runtimeobject.lib")

static BOOL init_windows_runtime(void);

static void quit_windows_runtime(void);

static BOOL create_windows_runtime_class_instance(
    PCWSTR class_id, REFIID riid, void** object);

static const IID IID___x_ABI_CWindows_CData_CJson_CIJsonObject = 
{
    0x064e24dd, 0x29c2, 0x4f83, {0x9a, 0xc1, 0x9e, 0xe1, 0x15, 0x78, 0xbe, 0xb3}
};

static BOOL init_windows_runtime(void)
{
    HRESULT hr = RoInitialize(RO_INIT_MULTITHREADED);
    return SUCCEEDED(hr);
}

static void quit_windows_runtime(void)
{
    RoUninitialize();
}

static BOOL create_windows_runtime_class_instance(
    PCWSTR class_id, REFIID riid, void** object)
{
    HRESULT        hr;
    HSTRING_HEADER class_id_header;
    HSTRING        class_id_string;
    IInspectable*  inspectable;

    *object = NULL;

    hr = WindowsCreateStringReference(
        class_id, (UINT32)wcslen(class_id),
        &class_id_header, &class_id_string);

    if (FAILED(hr))
    {
        return FALSE;
    }

    hr = RoActivateInstance(class_id_string, &inspectable);
    if (FAILED(hr))
    {
        return FALSE;
    }

    hr = inspectable->lpVtbl->QueryInterface(inspectable, riid, object);
    inspectable->lpVtbl->Release(inspectable);

    return SUCCEEDED(hr);
}

int main(int argc, char* argv[])
{
    __x_ABI_CWindows_CData_CJson_CIJsonObject* json_object;

    if (!init_windows_runtime())
    {
        return EXIT_FAILURE;
    }

    if (!create_windows_runtime_class_instance(
        RuntimeClass_Windows_Data_Json_JsonObject,
        &IID___x_ABI_CWindows_CData_CJson_CIJsonObject,
        &json_object))
    {
        quit_windows_runtime();
        return EXIT_FAILURE;
    }

    /* And there it is, your COM interface: json_object                       */
    /* You can set values using the json_object->lpVtbl->SetNamedValue method */
    /* You can get values using one of the json_object->lpVtbl->Get* methods  */
    /* Keep in mind that most of the parameters are Windows Runtime objects   */
    /* as well, meaning you have to do the above for them. Wrap up their      */
    /* class id/name in a HSTRING reference, create instance which gives an   */
    /* IInspectable interface, query that interface for desired interface.    */
    /* The header file windows.data.json.h contains all the necessary info.   */

    /* An example method call: */
    {
        HRESULT    hr;
        TrustLevel trust_level;

        hr = json_object->lpVtbl->GetTrustLevel(json_object, &trust_level);
        if (SUCCEEDED(hr))
        {
            printf("Trust level: ");
            switch (trust_level)
            {
                case BaseTrust:    { printf("Base\n");     break; }
                case PartialTrust: { printf("Partial\n");  break; }
                case FullTrust:    { printf("Fulll\n");    break; }
                default:           { printf("Unknown?\n"); break; }
            }
        }
    }

    json_object->lpVtbl->Release(json_object);

    quit_windows_runtime();
    return EXIT_SUCCESS;
}
```

Parsing JSON using C [closed]

We used it in this way, compiling JSON-C as a static library that is linked in
with the main build. That way, we don’t have to worry about dependencies
(other than installing Xcode). JSON-C …

const nx_json* json=nx_json_parse_utf8(code);
printf("hello=%s\n", nx_json_get(json, "hello")->text_value);
const nx_json* arr=nx_json_get(json, "my-array");
int i;
for (i=0; i<arr->length; i++) {
  const nx_json* item=nx_json_item(arr, i);
  printf("arr[%d]=(%d) %ld\n", i, (int)item->type, item->int_value);
}
nx_json_free(json);

JSON — Parse JSON Strings in Windows Runtime Components

Parsing JSON Objects in Managed Code. The Windows.Data.Json namespace includes
a number of different classes designed to work with JSON objects in a strongly
typed …

{
  firstName: "Craig"
}



"{
  '_backingData': {
    'firstName': 'Craig'
  },
  'firstName': 'Craig',
  'backingData': {
    'firstName':'Craig'}
}"



JsonValue root;
JsonObject jsonObject;
string firstName;
if (JsonValue.TryParse(jsonString, out root))
{
  jsonObject = root.GetObject();
  if (jsonObject.ContainsKey("firstName"))
  {
    firstName = jsonObject.GetNamedString("firstName");
  }
}



public static string GetStringValue(this JsonObject jsonObject, 
  string key)
{
  IJsonValue value;
  string returnValue = string.Empty;
  if (jsonObject.ContainsKey(key))
  {
    if (jsonObject.TryGetValue(key, out value))
    {
      if (value.ValueType == JsonValueType.String)
      {
        returnValue = jsonObject.GetNamedString(key);
      }
      else if (value.ValueType == JsonValueType.Number)
      {
        returnValue = jsonObject.GetNamedNumber(key).ToString();
      }
      else if (value.ValueType == JsonValueType.Boolean)
      {
        returnValue = jsonObject.GetNamedBoolean(key).ToString();
      }
    }
  }
  return returnValue;
}



public static bool? GetBooleanValue(this JsonObject jsonObject, 
  string key)
{
  IJsonValue value;
  bool? returnValue = null;
  if (jsonObject.ContainsKey(key))
  {
    if (jsonObject.TryGetValue(key, out value))
    {
      if (value.ValueType == JsonValueType.String)
      {
        string v = jsonObject.GetNamedString(key).ToLower();
        if (v == "1" || v == "true")
        {
          returnValue = true;
        }
        else if (v == "0" || v == "false")
        {
          returnValue = false;
        }
      }
      else if (value.ValueType == JsonValueType.Number)
      {
        int v = Convert.ToInt32(jsonObject.GetNamedNumber(key));
        if (v == 1)
        {
          returnValue = true;
        }
        else if (v == 0)
        {
          returnValue = false;
        }
      }
      else if (value.ValueType == JsonValueType.Boolean)
      {
        returnValue = value.GetBoolean();
      }
    }
  }
  return returnValue;
}



public static double? GetDoubleValue(this JsonObject jsonObject, 
  string key)
{
  IJsonValue value;
  double? returnValue = null;
  double parsedValue;
  if (jsonObject.ContainsKey(key))
  {
    if (jsonObject.TryGetValue(key, out value))
    {
      if (value.ValueType == JsonValueType.String)
      {
        if (double.TryParse(jsonObject.GetNamedString(key), 
          out parsedValue))
        {
          returnValue = parsedValue;
        }
      }
      else if (value.ValueType == JsonValueType.Number)
      {
        returnValue = jsonObject.GetNamedNumber(key);
      }
    }
  }
  return returnValue;
}



public static int? GetIntegerValue(this JsonObject jsonObject, 
  string key)
{
  double? value = jsonObject.GetDoubleValue(key);
  int? returnValue = null;
  if (value.HasValue)
  {
    returnValue = Convert.ToInt32(value.Value);
  }
  return returnValue;
}



internal class Person
{
  public int Id { get; set; }
  public string FirstName { get; set; }
  public string LastName { get; set; }
  public bool? IsOnWestCoast { get; set; }
}



public static Person Create(string jsonString)
{
  JsonValue json;
  Person person = new Person();
  if (JsonValue.TryParse(jsonString, out json))
  {
    person = PersonFactory.Create(json);
  }
  return person;
}



public static Person Create(JsonValue personValue)
{
  Person person = new Person();
  JsonObject jsonObject = personValue.GetObject();
  int? id = jsonObject.GetIntegerValue("id");
  if (id.HasValue)
  {
    person.Id = id.Value;
  }
  person.FirstName = jsonObject.GetStringValue("firstName");
  person.LastName = jsonObject.GetStringValue("lastName");
  bool? isOnWestCoast = jsonObject.GetBooleanValue("isOnWestCoast");
  if (isOnWestCoast.HasValue)
  {
    person.IsOnWestCoast = isOnWestCoast.Value;
  }
  return person;
}



public static IList<Person> CreateList(string peopleJson)
{
  List<Person> people = new List<Person>();
  JsonArray array = new JsonArray();
  if (JsonArray.TryParse(peopleJson, out array))
  {
    if (array.Count > 0)
    {
      foreach (JsonValue value in array)
      {
        people.Add(PersonFactory.Create(value));
      }
    }
  }
  return people;
}



using System.Collections.Generic;
public sealed class ContactsManager
{
  private string AddContact(string personJson)
  {
    Person person = PersonFactory.Create(personJson);
    return string.Format("{0} {1} is added to the system.",
      person.FirstName,
      person.LastName);
  }
  private string AddContacts(string personJson)
  {
    IList<Person> people = PersonFactory.CreateList(personJson);
    return string.Format("{0} {1} and {2} {3} are added to the system.",
      people[0].FirstName,
      people[0].LastName,
      people[1].FirstName,
      people[1].LastName);
  }
}



using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Windows.Foundation;
public IAsyncOperation<string> AddContactAsync(string personJson)
{
  return Task.Run<string>(() =>
  {
    return this.AddContact(personJson);
  }).AsAsyncOperation();
}



var _model = {
  contact: {
    id: 1000,
    firstName: "Craig",
    lastName: "Shoemaker"
  },
  contacts: [
    {
      id: 1001,
      firstName: "Craig",
      lastName: "Shoemaker",
      isOnWestCoast: "true"
    },
    {
      id: 1002,
      firstName: "Jason",
      lastName: "Beres",
      isOnWestCoast: "0"
    }
  ]
}



var _vm = {
  ViewModel: WinJS.Binding.as({
    model: _model,
    contactMsg: "",
    contactsMsg: "",
    addContact: function () {
      var mgr = ParseJSON.Utility.ContactsManager();
      var jsonString = JSON.stringify(_vm.ViewModel.model.contact);
      mgr.addContactAsync(jsonString).done(function (response) {
        _vm.ViewModel.contactMsg = response;
      });
    },
    addContacts: function () {
      var mgr = ParseJSON.Utility.ContactsManager();
      var jsonString = JSON.stringify(_vm.ViewModel.model.contacts);
        mgr.addContactsAsync(jsonString).done(function (response) {
          _vm.ViewModel.contactsMsg = response;
        });
      }
  })
};



<section aria-label="Main content" role="main">
  <div data-win-bindsource=
    "Application.Pages.Home.ViewModel">
    <h2 data-win-bind="innerText: contactMsg"></h2>
    <hr />
    <h2 data-win-bind="innerText: contactsMsg"></h2>
  </div>
</section>

A guide to JSON using C++

A JSON object. This tutorial will teach us to work with JSON data using
various C++ libraries. We will use the above JSON object as an example. JSON
with C++

{“name”: “Joe”,“grade”: “A”}


#include <iostream>#include <fstream>// including JsonCpp header file#include <jsoncpp/json/json.h>using namespace std;int main() {// read fileifstream file(“data.json”);// json readerJson::Reader reader;// this will contain complete JSON dataJson::Value completeJsonData;// reader reads the data and stores it in completeJsonDatareader.parse(file, completeJsonData);// complete JSON datacout << “Complete JSON data: “ << endl << completeJsGrade << endl;// get the value associated with name keycout << “Name: “ << completeJsonData[“name”] << endl;// get the value associated with grade keycout << “Grade: “ << completeJsonData[“grade”] << endl;}


Complete JSON data{“name”: “Joe”,“grade”; “A”}Name: “Joe”Grade: “A”


#include <nlohmann/json.hpp>


using json = nlohmann::json;


#include <iostream>#include <fstream>#include <nlohmann/json.hpp>using namespace std;using json = nlohmann::json;int main(){std::ifstream f(“data.json”);json data = json::parse(f);// Access the values existing in JSON datastring name = data.value(“name”, “not found”);string grade = data.value(“grade”, “not found”);// Access a value that does not exist in the JSON datastring email = data.value(“email”, “not found”);// Print the valuescout << “Name: “ << name << endl;cout << “Grade: “ << grade << endl;cout << “Email: “ << email << endl;return 0;}


Name: JoeGrade: AEmail: not found


#include <iostream>// including RapidJSON header files#include “rapidjson/document.h”#include “rapidjson/stringbuffer.h”#include “rapidjson/writer.h”using namespace rapidjson;int main() {// JSON stringconst char *json = “{\”name\”:\”Joe\”,\”grade\”:\”A\”}”;// Parsing the JSON string into DOM.Document DOM;DOM.Parse(json);// Stringifying the DOMStringBuffer buffer;Writer<StringBuffer> writer(buffer);DOM.Accept(writer);std::string completeJsonData = buffer.GetString();std::cout << completeJsonData << std::endl;return 0;}


{“name”:”Joe”,”grade”:”A”}


#include <iostream>// Including taoJSON header files#include <tao/json.hpp>#include <tao/json/contrib/traits.hpp>using namespace std;int main() {// Parsing stringconst tao::json::value parsedJson = tao::json::from_string(“{ \”name\”: \”Joe\”, \”grade\”: \”A\” }”);cout << parsedJson << endl;return 0;}


{“grade”:”A”,”name”:”Joe”}

How to parse json data in c#.net windows form application?

Solution 1. First have a search in CodeProject [ ^ ]with your query.Also see..
A reply to your own question which contains only links to resources you have
found may be …

{
"Movies":[
{"Movie":
{"id":"102",
"name":"Bombay Talkies",
"image":"http:\/\/projects.com\/gettickets\/img\/uploads\/movie\/original\/1367224274168.jpg",
"type":"B",
"language":"Hindi",
"certificate":"U\/A",
"genre":"Drama",
"cast":"Rani Mukerji, Randeep Hooda, Saqib Saleem, Katrina Kaif, Sadashiv Amrapurkar, Nawazuddin Siddiqui, Ranvir Shorey, Naman Jain , Sudhir Pandey",
"director":"Anurag Kashyap, Karan Johar, Zoya Akhtar, Dibakar ",
"producer":"Zoya Akhtar",
"created":"2013-04-29"}}]}

How to manipulate and use JSON with C# and WinForms

When the search menu appears, type JSON.NET , select the WinForms
distributtion and install it. As with every version of Visual Studio, the
interface may vary, just be …

Attempting to gather dependency information for package 'Newtonsoft.Json.8.0.3' with respect to project 'UniversalSandbox', targeting '.NETFramework,Version=v4.5.2'
Attempting to resolve dependencies for package 'Newtonsoft.Json.8.0.3' with DependencyBehavior 'Lowest'
Resolving actions to install package 'Newtonsoft.Json.8.0.3'
Resolved actions to install package 'Newtonsoft.Json.8.0.3'
  GET https://api.nuget.org/packages/newtonsoft.json.8.0.3.nupkg
  OK https://api.nuget.org/packages/newtonsoft.json.8.0.3.nupkg 27ms
Installing Newtonsoft.Json 8.0.3.
Adding package 'Newtonsoft.Json.8.0.3' to folder 'F:\C# Development\Winform projects\UniversalSandbox\packages'
Added package 'Newtonsoft.Json.8.0.3' to folder 'F:\C# Development\Winform projects\UniversalSandbox\packages'
Added package 'Newtonsoft.Json.8.0.3' to 'packages.config'
Executing script file 'F:\C# Development\Winform projects\UniversalSandbox\packages\Newtonsoft.Json.8.0.3\tools\install.ps1'...
Successfully installed 'Newtonsoft.Json 8.0.3' to UniversalSandbox
========== Finished ==========


using Newtonsoft.Json;


using Newtonsoft.Json;
using System.IO;

string json = @"{
   'CPU': 'Intel',
   'PSU': '500W',
   'Drives': [
     'DVD read/writer'
     /*(broken)*/,
     '500 gigabyte hard drive',
     '200 gigabype hard drive'
   ]
}";

JsonTextReader reader = new JsonTextReader(new StringReader(json));
while (reader.Read())
{
    if (reader.Value != null)
    {
        Console.WriteLine("Token: {0}, Value: {1}", reader.TokenType, reader.Value);
    }
    else
    {
        Console.WriteLine("Token: {0}", reader.TokenType);
    }
}

// Token: StartObject
// Token: PropertyName, Value: CPU
// Token: String, Value: Intel
// Token: PropertyName, Value: PSU
// Token: String, Value: 500W
// Token: PropertyName, Value: Drives
// Token: StartArray
// Token: String, Value: DVD read/writer
// Token: Comment, Value: (broken)
// Token: String, Value: 500 gigabyte hard drive
// Token: String, Value: 200 gigabype hard drive
// Token: EndArray
// Token: EndObject


using System.Dynamic;

dynamic myObject = new ExpandoObject();

myObject.name = "Our Code World";
myObject.website = "http://ourcodeworld.com";
myObject.language = "en-US";

List<string> articles = new List<string>();
articles.Add("How to manipulate JSON with C#");
articles.Add("Top 5: Best jQuery schedulers");
articles.Add("Another article title here ...");

myObject.articles = articles;

string json = JsonConvert.SerializeObject(myObject);

Console.WriteLine(json);

//{  
//   "name":"Our Code World",
//   "website":"http://ourcodeworld.com",
//   "language":"en-US",
//   "articles":[  
//      "How to manipulate JSON with C#",
//      "Top 5: Best jQuery schedulers",
//      "Another article title here ..."
//   ]
//}



public class SearchResult
{
    public string Title { get; set; }
    public string Content { get; set; }
    public string Url { get; set; }
}


using Newtonsoft.Json.Linq;

string googleSearchText = @"{
'responseData': {
'results': [
 {
 'GsearchResultClass': 'GwebSearch',
 'unescapedUrl': 'http://en.wikipedia.org/wiki/Paris_Hilton',
 'url': 'http://en.wikipedia.org/wiki/Paris_Hilton',
 'visibleUrl': 'en.wikipedia.org',
 'cacheUrl': 'http://www.google.com/search?q=cache:TwrPfhd22hYJ:en.wikipedia.org',
 'title': '<b>Paris Hilton</b> - Wikipedia, the free encyclopedia',
 'titleNoFormatting': 'Paris Hilton - Wikipedia, the free encyclopedia',
 'content': '[1] In 2006, she released her debut album...'
 },
 {
 'GsearchResultClass': 'GwebSearch',
 'unescapedUrl': 'http://www.imdb.com/name/nm0385296/',
 'url': 'http://www.imdb.com/name/nm0385296/',
 'visibleUrl': 'www.imdb.com',
 'cacheUrl': 'http://www.google.com/search?q=cache:1i34KkqnsooJ:www.imdb.com',
 'title': '<b>Paris Hilton</b>',
 'titleNoFormatting': 'Paris Hilton',
 'content': 'Self: Zoolander. Socialite <b>Paris Hilton</b>...'
 }
],
'cursor': {
 'pages': [
 {
 'start': '0',
 'label': 1
 },
 {
 'start': '4',
 'label': 2
 },
 {
 'start': '8',
 'label': 3
 },
 {
 'start': '12',
 'label': 4
 }
 ],
 'estimatedResultCount': '59600000',
 'currentPageIndex': 0,
 'moreResultsUrl': 'http://www.google.com/search?oe=utf8&ie=utf8...'
}
},
'responseDetails': null,
'responseStatus': 200
}";

JObject googleSearch = JObject.Parse(googleSearchText);

// get JSON result objects into a list
IList<JToken> results = googleSearch["responseData"]["results"].Children().ToList();

// serialize JSON results into .NET objects
IList<SearchResult> searchResults = new List<SearchResult>();
foreach (JToken result in results)
{
   SearchResult searchResult = JsonConvert.DeserializeObject<SearchResult>(result.ToString());
   searchResults.Add(searchResult);
}

// List the properties of the searchResults IList
foreach (SearchResult item in searchResults)
{
 Console.WriteLine(item.Title);
 Console.WriteLine(item.Content);
 Console.WriteLine(item.Url);
}

// Title = <b>Paris Hilton</b> - Wikipedia, the free encyclopedia
// Content = [1] In 2006, she released her debut album...
// Url = http://en.wikipedia.org/wiki/Paris_Hilton

// Title = <b>Paris Hilton</b>
// Content = Self: Zoolander. Socialite <b>Paris Hilton</b>...
// Url = http://www.imdb.com/name/nm0385296/

Parsing JSON string in Windows 8 Metro applications using C

Hi, I have used the following code for retrieving json string, but unable to
parse the json in windows 8 c# applications. var client = new HttpClient();
var response = await …

public class Shop
{
   public int shop_id { get; set; }
   public string shop_name { get; set; }
}