darktable / MiniJSON.cs
Created

Embed URL

HTTPS clone URL

SSH clone URL

You can clone with HTTPS or SSH.

Download Gist

Unity3D: MiniJSON Decodes and encodes simple JSON strings. Not intended for use with massive JSON strings, probably < 32k preferred. Handy for parsing JSON from inside Unity3d.

View MiniJSON.cs
Raw
File suppressed. Click to show.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 
/*

 * Copyright (c) 2013 Calvin Rien

 *

 * Based on the JSON parser by Patrick van Bergen

 * http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html

 *

 * Simplified it so that it doesn't throw exceptions

 * and can be used in Unity iPhone with maximum code stripping.

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Text;

 

namespace MiniJSON {

    // Example usage:

    //

    //  using UnityEngine;

    //  using System.Collections;

    //  using System.Collections.Generic;

    //  using MiniJSON;

    //

    //  public class MiniJSONTest : MonoBehaviour {

    //      void Start () {

    //          var jsonString = "{ \"array\": [1.44,2,3], " +

    //                          "\"object\": {\"key1\":\"value1\", \"key2\":256}, " +

    //                          "\"string\": \"The quick brown fox \\\"jumps\\\" over the lazy dog \", " +

    //                          "\"unicode\": \"\\u3041 Men\u00fa sesi\u00f3n\", " +

    //                          "\"int\": 65536, " +

    //                          "\"float\": 3.1415926, " +

    //                          "\"bool\": true, " +

    //                          "\"null\": null }";

    //

    //          var dict = Json.Deserialize(jsonString) as Dictionary<string,object>;

    //

    //          Debug.Log("deserialized: " + dict.GetType());

    //          Debug.Log("dict['array'][0]: " + ((List<object>) dict["array"])[0]);

    //          Debug.Log("dict['string']: " + (string) dict["string"]);

    //          Debug.Log("dict['float']: " + (double) dict["float"]); // floats come out as doubles

    //          Debug.Log("dict['int']: " + (long) dict["int"]); // ints come out as longs

    //          Debug.Log("dict['unicode']: " + (string) dict["unicode"]);

    //

    //          var str = Json.Serialize(dict);

    //

    //          Debug.Log("serialized: " + str);

    //      }

    //  }

 

    /// <summary>

    /// This class encodes and decodes JSON strings.

    /// Spec. details, see http://www.json.org/

    ///

    /// JSON uses Arrays and Objects. These correspond here to the datatypes IList and IDictionary.

    /// All numbers are parsed to doubles.

    /// </summary>

    public static class Json {

        /// <summary>

        /// Parses the string json into a value

        /// </summary>

        /// <param name="json">A JSON string.</param>

        /// <returns>An List&lt;object&gt;, a Dictionary&lt;string, object&gt;, a double, an integer,a string, null, true, or false</returns>

        public static object Deserialize(string json) {

            // save the string for debug information

            if (json == null) {

                return null;

            }

 

            return Parser.Parse(json);

        }

 

        sealed class Parser : IDisposable {

            const string WORD_BREAK = "{}[],:\"";

 

            public static bool IsWordBreak(char c) {

                return Char.IsWhiteSpace(c) || WORD_BREAK.IndexOf(c) != -1;

            }

 

            enum TOKEN {

                NONE,

                CURLY_OPEN,

                CURLY_CLOSE,

                SQUARED_OPEN,

                SQUARED_CLOSE,

                COLON,

                COMMA,

                STRING,

                NUMBER,

                TRUE,

                FALSE,

                NULL

            };

 

            StringReader json;

 

            Parser(string jsonString) {

                json = new StringReader(jsonString);

            }

 

            public static object Parse(string jsonString) {

                using (var instance = new Parser(jsonString)) {

                    return instance.ParseValue();

                }

            }

 

            public void Dispose() {

                json.Dispose();

                json = null;

            }

 

            Dictionary<string, object> ParseObject() {

                Dictionary<string, object> table = new Dictionary<string, object>();

 

                // ditch opening brace

                json.Read();

 

                // {

                while (true) {

                    switch (NextToken) {

                    case TOKEN.NONE:

                        return null;

                    case TOKEN.COMMA:

                        continue;

                    case TOKEN.CURLY_CLOSE:

                        return table;

                    default:

                        // name

                        string name = ParseString();

                        if (name == null) {

                            return null;

                        }

 

                        // :

                        if (NextToken != TOKEN.COLON) {

                            return null;

                        }

                        // ditch the colon

                        json.Read();

 

                        // value

                        table[name] = ParseValue();

                        break;

                    }

                }

            }

 

            List<object> ParseArray() {

                List<object> array = new List<object>();

 

                // ditch opening bracket

                json.Read();

 

                // [

                var parsing = true;

                while (parsing) {

                    TOKEN nextToken = NextToken;

 

                    switch (nextToken) {

                    case TOKEN.NONE:

                        return null;

                    case TOKEN.COMMA:

                        continue;

                    case TOKEN.SQUARED_CLOSE:

                        parsing = false;

                        break;

                    default:

                        object value = ParseByToken(nextToken);

 

                        array.Add(value);

                        break;

                    }

                }

 

                return array;

            }

 

            object ParseValue() {

                TOKEN nextToken = NextToken;

                return ParseByToken(nextToken);

            }

 

            object ParseByToken(TOKEN token) {

                switch (token) {

                case TOKEN.STRING:

                    return ParseString();

                case TOKEN.NUMBER:

                    return ParseNumber();

                case TOKEN.CURLY_OPEN:

                    return ParseObject();

                case TOKEN.SQUARED_OPEN:

                    return ParseArray();

                case TOKEN.TRUE:

                    return true;

                case TOKEN.FALSE:

                    return false;

                case TOKEN.NULL:

                    return null;

                default:

                    return null;

                }

            }

 

            string ParseString() {

                StringBuilder s = new StringBuilder();

                char c;

 

                // ditch opening quote

                json.Read();

 

                bool parsing = true;

                while (parsing) {

 

                    if (json.Peek() == -1) {

                        parsing = false;

                        break;

                    }

 

                    c = NextChar;

                    switch (c) {

                    case '"':

                        parsing = false;

                        break;

                    case '\\':

                        if (json.Peek() == -1) {

                            parsing = false;

                            break;

                        }

 

                        c = NextChar;

                        switch (c) {

                        case '"':

                        case '\\':

                        case '/':

                            s.Append(c);

                            break;

                        case 'b':

                            s.Append('\b');

                            break;

                        case 'f':

                            s.Append('\f');

                            break;

                        case 'n':

                            s.Append('\n');

                            break;

                        case 'r':

                            s.Append('\r');

                            break;

                        case 't':

                            s.Append('\t');

                            break;

                        case 'u':

                            var hex = new char[4];

 

                            for (int i=0; i< 4; i++) {

                                hex[i] = NextChar;

                            }

 

                            s.Append((char) Convert.ToInt32(new string(hex), 16));

                            break;

                        }

                        break;

                    default:

                        s.Append(c);

                        break;

                    }

                }

 

                return s.ToString();

            }

 

            object ParseNumber() {

                string number = NextWord;

 

                if (number.IndexOf('.') == -1) {

                    long parsedInt;

                    Int64.TryParse(number, out parsedInt);

                    return parsedInt;

                }

 

                double parsedDouble;

                Double.TryParse(number, out parsedDouble);

                return parsedDouble;

            }

 

            void EatWhitespace() {

                while (Char.IsWhiteSpace(PeekChar)) {

                    json.Read();

 

                    if (json.Peek() == -1) {

                        break;

                    }

                }

            }

 

            char PeekChar {

                get {

                    return Convert.ToChar(json.Peek());

                }

            }

 

            char NextChar {

                get {

                    return Convert.ToChar(json.Read());

                }

            }

 

            string NextWord {

                get {

                    StringBuilder word = new StringBuilder();

 

                    while (!IsWordBreak(PeekChar)) {

                        word.Append(NextChar);

 

                        if (json.Peek() == -1) {

                            break;

                        }

                    }

 

                    return word.ToString();

                }

            }

 

            TOKEN NextToken {

                get {

                    EatWhitespace();

 

                    if (json.Peek() == -1) {

                        return TOKEN.NONE;

                    }

 

                    switch (PeekChar) {

                    case '{':

                        return TOKEN.CURLY_OPEN;

                    case '}':

                        json.Read();

                        return TOKEN.CURLY_CLOSE;

                    case '[':

                        return TOKEN.SQUARED_OPEN;

                    case ']':

                        json.Read();

                        return TOKEN.SQUARED_CLOSE;

                    case ',':

                        json.Read();

                        return TOKEN.COMMA;

                    case '"':

                        return TOKEN.STRING;

                    case ':':

                        return TOKEN.COLON;

                    case '0':

                    case '1':

                    case '2':

                    case '3':

                    case '4':

                    case '5':

                    case '6':

                    case '7':

                    case '8':

                    case '9':

                    case '-':

                        return TOKEN.NUMBER;

                    }

 

                    switch (NextWord) {

                    case "false":

                        return TOKEN.FALSE;

                    case "true":

                        return TOKEN.TRUE;

                    case "null":

                        return TOKEN.NULL;

                    }

 

                    return TOKEN.NONE;

                }

            }

        }

 

        /// <summary>

        /// Converts a IDictionary / IList object or a simple type (string, int, etc.) into a JSON string

        /// </summary>

        /// <param name="json">A Dictionary&lt;string, object&gt; / List&lt;object&gt;</param>

        /// <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>

        public static string Serialize(object obj) {

            return Serializer.Serialize(obj);

        }

 

        sealed class Serializer {

            StringBuilder builder;

 

            Serializer() {

                builder = new StringBuilder();

            }

 

            public static string Serialize(object obj) {

                var instance = new Serializer();

 

                instance.SerializeValue(obj);

 

                return instance.builder.ToString();

            }

 

            void SerializeValue(object value) {

                IList asList;

                IDictionary asDict;

                string asStr;

 

                if (value == null) {

                    builder.Append("null");

                } else if ((asStr = value as string) != null) {

                    SerializeString(asStr);

                } else if (value is bool) {

                    builder.Append((bool) value ? "true" : "false");

                } else if ((asList = value as IList) != null) {

                    SerializeArray(asList);

                } else if ((asDict = value as IDictionary) != null) {

                    SerializeObject(asDict);

                } else if (value is char) {

                    SerializeString(new string((char) value, 1));

                } else {

                    SerializeOther(value);

                }

            }

 

            void SerializeObject(IDictionary obj) {

                bool first = true;

 

                builder.Append('{');

 

                foreach (object e in obj.Keys) {

                    if (!first) {

                        builder.Append(',');

                    }

 

                    SerializeString(e.ToString());

                    builder.Append(':');

 

                    SerializeValue(obj[e]);

 

                    first = false;

                }

 

                builder.Append('}');

            }

 

            void SerializeArray(IList anArray) {

                builder.Append('[');

 

                bool first = true;

 

                foreach (object obj in anArray) {

                    if (!first) {

                        builder.Append(',');

                    }

 

                    SerializeValue(obj);

 

                    first = false;

                }

 

                builder.Append(']');

            }

 

            void SerializeString(string str) {

                builder.Append('\"');

 

                char[] charArray = str.ToCharArray();

                foreach (var c in charArray) {

                    switch (c) {

                    case '"':

                        builder.Append("\\\"");

                        break;

                    case '\\':

                        builder.Append("\\\\");

                        break;

                    case '\b':

                        builder.Append("\\b");

                        break;

                    case '\f':

                        builder.Append("\\f");

                        break;

                    case '\n':

                        builder.Append("\\n");

                        break;

                    case '\r':

                        builder.Append("\\r");

                        break;

                    case '\t':

                        builder.Append("\\t");

                        break;

                    default:

                        int codepoint = Convert.ToInt32(c);

                        if ((codepoint >= 32) && (codepoint <= 126)) {

                            builder.Append(c);

                        } else {

                            builder.Append("\\u");

                            builder.Append(codepoint.ToString("x4"));

                        }

                        break;

                    }

                }

 

                builder.Append('\"');

            }

 

            void SerializeOther(object value) {

                // NOTE: decimals lose precision during serialization.

                // They always have, I'm just letting you know.

                // Previously floats and doubles lost precision too.

                if (value is float) {

                    builder.Append(((float) value).ToString("R"));

                } else if (value is int

                    || value is uint

                    || value is long

                    || value is sbyte

                    || value is byte

                    || value is short

                    || value is ushort

                    || value is ulong) {

                    builder.Append(value);

                } else if (value is double

                    || value is decimal) {

                    builder.Append(Convert.ToDouble(value).ToString("R"));

                } else {

                    SerializeString(value.ToString());

                }

            }

        }

    }

}
nikibobi commented

I found one nasty bug. When I serialize a double that is a whole number like 1, it writes it like 1. And when the parser wants to parse it it doesn't have '.' and it reads it as integer type. I suggest splitting the if on line 530 for ints and floats and then doing something like string.Format("0.0"); for the floats.

Other than that your mini json lib is very useful and I thank you for doing it :D

TokyoDan commented

Can this work with 2 dimensional arrays?

DerellNar commented

Fixed the float, double, decimal issue where the serialiser saved it as "0" instead of "0.0"

In the Function SerializeOther at Line 529
I added an extra else if to handle float, double and decimal separately:

void SerializeOther(object value) {
if (value is int
|| value is uint
|| value is long
|| value is sbyte
|| value is byte
|| value is short
|| value is ushort
|| value is ulong) {
builder.Append(value.ToString());
}
else if (value is float
|| value is double
|| value is decimal)
{
builder.Append(string.Format("{0:F}", value));
}
else {
SerializeString(value.ToString());
}
}

tonyzahnle commented

Has anyone come across a bug where when it tries to serialize a dictionary, it instead makes the string into something like this?:
"SaveData":"{\"S\":null,\"y\":null,\"s\":null,\"t\":null,\"e\":null,\"m\":null,\".\":null,\"C\":null,\"o\":null,\"l\":null,\"l\":null,\"e\":null,\"c\":null,\"t\":null,\"i\":null,\"o\":null,\"n\":null,\"s\":null,\".\":null,\"G\":null,\"e\":null,\"n\":null,\"e\":null,\"r\":null,\"i\":null,\"c\":null,\".\":null,\"D\":null,\"i\":null,\"c\":null,\"t\":null,\"i\":null,\"o\":null,\"n\":null,\"a\":null,\"r\":null,\"y\":null,\"`\":null,\"2\":null,\"[\":null,\"S\":null,\"y\":null,\"s\":null,\"t\":null,\"e\":null,\"m\":null,\".\":null,\"S\":null,\"t\":null,\"r\":null,\"i\":null,\"n\":null,\"g\":null,\",\":null,\"S\":null,\"y\":null,\"s\":null,\"t\":null,\"e\":null,\"m\":null,\".\":null,\"O\":null,\"b\":null,\"j\":null,\"e\":null,\"c\":null,\"t\":null,\"]\":null}"

System.Collections.Generic.Dictionary`2[System.String,System.Object]

It's as if instead of grabbing the keys, it's grabbing each character of the type somehow. This appears to be happening randomly, working sometimes, but not others.

chrisnewhouse commented

@tonyzahnle, I saw some similar issues using this and other JSON libraries. If you swap all the generic collections in this code for Hashtables and ArrayLists it will fix your issue. I think that Unity for iOS has some kind of problem with iterating over generic collections. More about the issue here, although their fix didn't completely solve it for me.

LevWyeth commented

What exactly would be the problem with an extremely large json string? Im pretty sure we are using strings larger than that just fine...

elaberge commented

This implementation currently generates and parses invalid JSON when the system locale is set to use comma instead of periods with decimal numbers. By instructing TryParse and ToString to ignore the user locale, this fixes the issue.
See: https://gist.github.com/elaberge/6536806

butaca commented

Apparently, the Mono runtime incorrectly handles the current locale and in most situations returns en-us or invariant, at least in the current Unity3D version (4.2.1) and earlier. https://bugzilla.xamarin.com/show_bug.cgi?id=2957

So number parsing and encoding is working by chance. If the Mono runtime is fixed, the code will be broken. You should consider @elaberge suggestions.

As a side note, I encourage you to replace foreach with a standard for when possible (check out my fork, for performance).

Great work by the way and thanks for sharing! :)

vzack commented

Deserializing large ulong (UInt64) returns 0.
e.g. {"sessionid":12156480978394720353}

Following code return zero:

    if (number.IndexOf('.') == -1)
    {
        long parsedInt;
        Int64.TryParse(number, out parsedInt);

Solution 1:
Serialize as a long. (as -ve number)

Solution 2:

if (number.IndexOf('.') == -1) {
    long parsedInt;
    Int64.TryParse(number, out parsedInt);
    if (parsedInt==0) {
        ulong parsedUInt;
        UInt64.TryParse(number, out parsedUInt);
        return parsedUInt;
    }
    return parsedInt;
}

Solution 3:

if (number.IndexOf('.') == -1) {
    if (number.IndexOf('-') == -1) {
        ulong parsedUInt;
        UInt64.TryParse(number, out parsedUInt);
        return parsedUInt;
    } 
    long parsedInt;
    Int64.TryParse(number, out parsedInt);
    return parsedInt;
}
MaZyGer commented

Hello I have problem.

void Start () {
  Dictionary<int, int> test = new Dictionary<int, int>();
  test.Add(0, 1);
  test.Add(1, 1);

  string serialized = Json.Serialize(test);
  Debug.Log(serialized); // output {"0":1,"1":1}

  var data = Json.Deserialize(serialized) as Dictionary<string,object>;
  Debug.Log(data["0"]); //output 1
}

The problem is that i need integer as Key and not string. Is it not possible to change?
I am usnig for games Items with ID so it would really change everything if I have to save with string.

prestonmediaspike commented

MiniJSON causes an OutOfMemoryException on a machine with 8GB of RAM on the following invalid JSON string:

{"r":[{"a:["http:

It also blocks for 10+ seconds before doing so.

Solution:
Change the switch statement in ParseArray() to:

switch (nextToken) 
{
case TOKEN.NONE:
    return null;
case TOKEN.COMMA:
    continue;
case TOKEN.SQUARED_CLOSE:
    parsing = false;
    break;              
case TOKEN.COLON:
    json.Read(); //invalid array: consume colon to prevent infinite loop
    break;
default:
    object value = ParseByToken(nextToken);

    array.Add(value);
    break;
}
wexen commented

Hi ... I am a bit noob on JSON and really also c#
Anyway I need to load some JSON and setup a gamegrid in unity3d based on a 2d array with the contents from JSON file.
I hope someone would offer me a short script to do it with MINIJson.

I hope to be able to make my game grid from this Json:

{
"layout" : [ [1, 0, 1, 1, 1, 1, 1, 1, 1 ],
[1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[1, 1, 1, 1, 3, 1, 1, 1, 1 ],
[1, 1, 0, 1, 1, 6, 1, 1, 1 ],
[1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[1, 2, 1, 1, 1, 1, 1, 1, 1 ],
[1, 1, 1, 1, 1, 1, 1, 1, 1 ],
[1, 1, 1, 0, 1, 1, 1, 1, 1 ],
[1, 1, 1, 1, 1, 1, 1, 1, 1 ] ],

}

But how would I go about to get this json from the dictionary to my int layout[9,9]

I hope someone will be able to help.
Thanks in advance :-)

wexen commented

I got the answer from stack
int[,] layout = new int[9,9];

var dict = (Dictionary)Json.Deserialize(jsonString);
var list = (List)dict["layout"];

for (int row = 0; row < 9; row++)
{
var items = (List)list[row];
for (int col = 0; col < 9; col++)
{
layout[row, col] = Convert.ToInt32(items[col]);
}
}

JMSams commented

I cannot get this to give me an array of a custom object. What is the correct way to do this?
I have tried casting the returned object to an array and a list but keep on getting an error saying that it cannot cast from the source type to the destination type.

kathees commented

How to use where clause in MiniJSON

I have 2 array names called categories and products and i'm getting the values from products table but i want to pass the id value from categories to products using WHERE clause. But how can i use WHERE in MiniJSON?

{"Categories":[{"id":"1","name":"Test1"},{"id":"2","name":"Test2"},}],

"Products":
[{"name":"Test2","category_id":"2","imageurl":"http://server.com/3DModel_images/Xpl.jpg"},
{"name":"Test1","category_id":"1","imageurl":"http://server.com/3DModel_images/favicon.jpg"},]}

IList linksObject = (IList) search["Products"]

  foreach (IDictionary ProductslinksArray in linksObject) {

   String modal3d=string.Format("{0} ", ProductslinksArray["imageurl"]); 

      //Here i need to pass the id value from categories  to products WHERE category_id=? (id value )   How can i use WHERE clause?

}

doterax commented

How to solve problems with double type:

object ParseNumber()
{
    string number = NextWord;
    if (number.IndexOf('.') == -1)
    {
        long parsedInt;
        Int64.TryParse(number, out parsedInt);
        return parsedInt;
    }
    double parsedDouble;
    //use invariant number format to parse double
    Double.TryParse(number, System.Globalization.NumberStyles.Float, System.Globalization.NumberFormatInfo.InvariantInfo, out parsedDouble);
    return parsedDouble;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.