Mapping JSON to objects and vice versa

In order to consume data in JSON format inside .Net programs, the natural approach that comes to mind is to use JSON text to populate a new instance of a particular class; either a custom one, built to match the structure of the input JSON text, or a more general one which acts as a dictionary.

Conversely, in order to build new JSON strings from data stored in objects, a simple export–like operation sounds like a good idea.

For this purpose, LitJSON includes the JsonMapper class, which provides two main methods used to do JSON–to–object and object–to–JSON conversions. These methods are JsonMapper.ToObject and JsonMapper.ToJson.

Simple JsonMapper examples

As the following example demonstrates, the ToObject method has a generic variant, JsonMapper.ToObject<T>, that is used to specify the type of the object to be returned.

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

using LitJson;
using System;

public class Person
{
    // C# 3.0 auto-implemented properties
    public string   Name     { get; set; }
    public int      Age      { get; set; }
    public DateTime Birthday { get; set; }
}

public class JsonSample
{
    public static void Main()
    {
        PersonToJson();
        JsonToPerson();
    }

    public static void PersonToJson()
    {
        Person bill = new Person();

        bill.Name = "William Shakespeare";
        bill.Age  = 51;
        bill.Birthday = new DateTime(1564, 4, 26);

        string json_bill = JsonMapper.ToJson(bill);

        Console.WriteLine(json_bill);
    }

    public static void JsonToPerson()
    {
        string json = @"
            {
                ""Name""     : ""Thomas More"",
                ""Age""      : 57,
                ""Birthday"" : ""02/07/1478 00:00:00""
            }";

        Person thomas = JsonMapper.ToObject<Person>(json);

        Console.WriteLine("Thomas' age: {0}", thomas.Age);
    }
}

Output from the example:

1
2

{"Name":"William Shakespeare","Age":51,"Birthday":"04/26/1564 00:00:00"}
Thomas' age: 57

Using the non–generic variant of JsonMapper.ToObject

When JSON data is to be read and a custom class that matches a particular data structure is not available or desired, users can use the non–generic variant of ToObject, which returns a JsonData instance. JsonData is a general purpose type that can hold any of the data types supported by JSON, including lists and dictionaries.

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

using LitJson;
using System;

public class JsonSample
{
    public static void Main()
    {
        string json = @"
          {
            ""album"" : {
              ""name""   : ""The Dark Side of the Moon"",
              ""artist"" : ""Pink Floyd"",
              ""year""   : 1973,
              ""tracks"" : [
                ""Speak To Me"",
                ""Breathe"",
                ""On The Run""
              ]
            }
          }
        ";

        LoadAlbumData(json);
    }

    public static void LoadAlbumData(string json_text)
    {
        Console.WriteLine("Reading data from the following JSON string: {0}",
                          json_text);

        JsonData data = JsonMapper.ToObject(json_text);

        // Dictionaries are accessed like a hash-table
        Console.WriteLine("Album's name: {0}", data["album"]["name"]);

        // Scalar elements stored in a JsonData instance can be cast to
        // their natural types
        string artist = (string) data["album"]["artist"];
        int    year   = (int) data["album"]["year"];

        Console.WriteLine("Recorded by {0} in {1}", artist, year);

        // Arrays are accessed like regular lists as well
        Console.WriteLine("First track: {0}", data["album"]["tracks"][0]);
    }
}

Output from the example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Reading data from the following JSON string:
          {
            "album" : {
              "name"   : "The Dark Side of the Moon",
              "artist" : "Pink Floyd",
              "year"   : 1973,
              "tracks" : [
                "Speak To Me",
                "Breathe",
                "On The Run"
              ]
            }
          }

Album's name: The Dark Side of the Moon
Recorded by Pink Floyd in 1973
First track: Speak To Me

Readers and Writers

An alternative interface to handling JSON data that might be familiar to some developers is through classes that make it possible to read and write data in a stream–like fashion. These classes are JsonReader and JsonWriter.

These two types are in fact the foundation of this library, and the JsonMapper type is built on top of them, so in a way, the developer can think of the reader and writer classes as the low–level programming interface for LitJSON.

Using JsonReader

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

using LitJson;
using System;

public class DataReader
{
    public static void Main()
    {
        string sample = @"{
            ""name""  : ""Bill"",
            ""age""   : 32,
            ""awake"" : true,
            ""n""     : 1994.0226,
            ""note""  : [ ""life"", ""is"", ""but"", ""a"", ""dream"" ]
          }";

        PrintJson(sample);
    }

    public static void PrintJson(string json)
    {
        JsonReader reader = new JsonReader(json);

        Console.WriteLine ("{0,14} {1,10} {2,16}", "Token", "Value", "Type");
        Console.WriteLine (new String ('-', 42));

        // The Read() method returns false when there's nothing else to read
        while (reader.Read()) {
            string type = reader.Value != null ?
                reader.Value.GetType().ToString() : "";

            Console.WriteLine("{0,14} {1,10} {2,16}",
                              reader.Token, reader.Value, type);
        }
    }
}

This example would produce the following output:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

         Token      Value             Type
------------------------------------------
   ObjectStart                            
  PropertyName       name    System.String
        String       Bill    System.String
  PropertyName        age    System.String
           Int         32     System.Int32
  PropertyName      awake    System.String
       Boolean       True   System.Boolean
  PropertyName          n    System.String
        Double  1994.0226    System.Double
  PropertyName       note    System.String
    ArrayStart                            
        String       life    System.String
        String         is    System.String
        String        but    System.String
        String          a    System.String
        String      dream    System.String
      ArrayEnd                            
     ObjectEnd                            

Using JsonWriter

The JsonWriter class is quite simple. Keep in mind that if you want to convert some arbitrary object into a JSON string, you’d normally just use JsonMapper.ToJson.

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

using LitJson;
using System;
using System.Text;

public class DataWriter
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder();
        JsonWriter writer = new JsonWriter(sb);

        writer.WriteArrayStart();
        writer.Write(1);
        writer.Write(2);
        writer.Write(3);

        writer.WriteObjectStart();
        writer.WritePropertyName("color");
        writer.Write("blue");
        writer.WriteObjectEnd();

        writer.WriteArrayEnd();

        Console.WriteLine(sb.ToString());
    }
}

Output from the example:

1

[1,2,3,{"color":"blue"}]

Configuring the library’s behaviour

JSON is a very concise data–interchange format; nothing more, nothing less. For this reason, handling data in JSON format inside a program may require a deliberate decision on your part regarding some little detail that goes beyond the scope of JSON’s specs.

Consider, for example, reading data from JSON strings where single–quotes are used to delimit strings, or Javascript–style comments are included as a form of documentation. Those things are not part of the JSON standard, but they are commonly used by some developers, so you may want to be forgiving or strict depending on the situation. Or what about if you want to convert a .Net object into a JSON string, but pretty–printed (using indentation)?

To declare the behaviour you want, you may change a few properties from your JsonReader and JsonWriter objects.

Configuration of JsonReader

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

using LitJson;
using System;

public class JsonReaderConfigExample
{
    public static void Main()
    {
        string json;

        json = " /* these are some numbers */ [ 2, 3, 5, 7, 11 ] ";
        TestReadingArray(json);

        json = " [ \"hello\", 'world' ] ";
        TestReadingArray(json);
    }

    static void TestReadingArray(string json_array)
    {
        JsonReader defaultReader, customReader;

        defaultReader = new JsonReader(json_array);
        customReader  = new JsonReader(json_array);

        customReader.AllowComments            = false;
        customReader.AllowSingleQuotedStrings = false;

        ReadArray(defaultReader);
        ReadArray(customReader);
    }

    static void ReadArray(JsonReader reader)
    {
        Console.WriteLine("Reading an array");

        try {
            JsonData data = JsonMapper.ToObject(reader);

            foreach (JsonData elem in data)
                Console.Write("  {0}", elem);

            Console.WriteLine("  [end]");
        }
        catch (Exception e) {
            Console.WriteLine("  Exception caught: {0}", e.Message);
        }
    }
}

The output would be:

1
2
3
4
5
6
7
8

Reading an array
  2  3  5  7  11  [end]
Reading an array
  Exception caught: Invalid character '/' in input string
Reading an array
  hello  world  [end]
Reading an array
  Exception caught: Invalid character ''' in input string

Configuration of JsonWriter

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

using LitJson;
using System;

public enum AnimalType
{
    Dog,
    Cat,
    Parrot
}

public class Animal
{
    public string     Name { get; set; }
    public AnimalType Type { get; set; }
    public int        Age  { get; set; }
    public string[]   Toys { get; set; }
}

public class JsonWriterConfigExample
{
    public static void Main()
    {
        var dog = new Animal {
            Name = "Noam Chompsky",
            Type = AnimalType.Dog,
            Age  = 3,
            Toys = new string[] { "rubber bone", "tennis ball" }
        };

        var cat = new Animal {
            Name = "Colonel Meow",
            Type = AnimalType.Cat,
            Age  = 5,
            Toys = new string[] { "cardboard box" }
        };

        TestWritingAnimal(dog);
        TestWritingAnimal(cat, 2);
    }

    static void TestWritingAnimal(Animal pet, int indentLevel = 0)
    {
        Console.WriteLine("\nConverting {0}'s data into JSON..", pet.Name);
        JsonWriter writer1 = new JsonWriter(Console.Out);
        JsonWriter writer2 = new JsonWriter(Console.Out);

        writer2.PrettyPrint = true;
        if (indentLevel != 0)
            writer2.IndentValue = indentLevel;

        Console.WriteLine("Default JSON string:");
        JsonMapper.ToJson(pet, writer1);

        Console.Write("\nPretty-printed:");
        JsonMapper.ToJson(pet, writer2);
        Console.WriteLine("");
    }
}

The output from this example is:

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

Converting Noam Chompsky's data into JSON..
Default JSON string:
{"Name":"Noam Chompsky","Type":0,"Age":3,"Toys":["rubber bone","tennis ball"]}
Pretty-printed:
{
    "Name" : "Noam Chompsky",
    "Type" : 0,
    "Age"  : 3,
    "Toys" : [
        "rubber bone",
        "tennis ball"
    ]
}

Converting Colonel Meow's data into JSON..
Default JSON string:
{"Name":"Colonel Meow","Type":1,"Age":5,"Toys":["cardboard box"]}
Pretty-printed:
{
  "Name" : "Colonel Meow",
  "Type" : 1,
  "Age"  : 5,
  "Toys" : [
    "cardboard box"
  ]
}

用 ILSPY 或者 .NET Reflector 、dnspy 等反编译出来之后 文件由于语法不符合已经被丢弃了，

所以在反编译工具里面找到这个类，手动复制出来，新建一个类，把尖括号等去掉，方法就只保留 ComputeStringHash 方法就行了。

再在报错的地方也把尖括号去掉。

这个方法原本是一个string类型的switch，switch本身就要计算hash来判断，但是反编译工具对这个的解析出了问题，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

[CompilerGenerated]
internal sealed class PrivateImplementationDetails
{
    internal static uint ComputeStringHash(string s)
    {
        uint num = 0;
        if(s != null)
        {
            num = 2166136261U;
            for(int i=0;i<s.Length;i++)
            {
                num = ((uint)s[i] ^ num)*16777619U;
            }
        }
        return num;
    }
}

重建类后测试 ComputeStringHash(“link”)最后的结果就是 232457833 ，

如果判断条件不多的话其实可以直接把这个数字判断全部删掉，重写switch或者if都可以。如果判断条件很多懒得弄就自建PrivateImplementationDetails是最简单的

1. sqlite_sequence

1
2

insert into TbTest(Name, Age) values('usr', 20);
select seq from sqlite_sequence where name='TbTest';

1. rowid

1
2
3
4
5
6

--表设置了自增列，会生成 rowid 的隐藏列，需要显式查询语句才可以查询出
select rowid from TbTest;
--但是，表没有设置自增列，上面的语句无法查出任何值
--特殊的，表无论是否设置了自增列，但都可以使用聚合函数查询出 rowid
insert into TbTest(Name, Age) values('usr', 20);
select max(rowid) from TbTest;

1. ID 列

1
2

insert into TbTest(Name, Age) values('usr', 20);
select max(ID) from TbTest;

1. last_insert_rowid

1
2
3

insert into TbTest(Name, Age) values('usr', 20);
--注意！若此行处有插入临时表的操作，下面的语句获取到的是插入临时表的 rowid
select last_insert_rowid() from TbTest LIMIT 1;

最的做的项目中要有到sqlite数据存储，写了测试程序进行测试，存入300万条记录，占用flash大小为 86.1M，当把表中的记录全部删除后发后数据库文件大小依然是 86.1M；

原因是： sqlite采用的是变长纪录存储，当你从Sqlite删除数据后，未使用的磁盘空间被添加到一个内在的”空闲列表”中用于存储你下次插入的数据，用于提高效率，磁盘空间并没有丢失，但也不向操作系统返回磁盘空间，这就导致删除数据乃至清空整个数据库后，数据文件大小还是没有任何变化，还是很大

解决方法：两种

一，在数据删除后，手动执行VACUUM命令，执行方式很简单

sqlite> vacuum；

VACUUM命令会清空“空闲列表”，把数据库尺寸压缩到最小。但是要耗费一些时间。

FQA里面说，在Linux的环境下，大约0.5秒/M。并且要使用两倍于数据库文件的空间。

我憎恨此FQA，他只说系统环境，不说机器硬件环境。我在测试手机上执行用了将近13秒时间压缩了将近3M的空间。至于它所占用的另一部分空间，是生成了一个.db-journal后缀名的临时文件。（这个问题对我现在来说是无所谓的。）

二，在数据库文件建成中，将auto_vacuum设置成“1”。

注意：只有在数据库中未建任何表时才能改变auto-vacuum标记。试图在已有表的情况下修改不会导致报错。

cmd.CommandText = “PRAGMA auto_vacuum = 1;”

cmd.ExecuteNonQuery()

当开启auto-vacuum，当提交一个从数据库中删除除数据的事物时，数据库文件自动收缩。

数据库会在内部存储一些信息以便支持这一功能，这使得数据库文件比不开启该选项时稍微大一些。

我的表结构，不含任何数据是，数据库文件大小是25K左右，开了auto_vacuum之后是26K。

插入运行基础数据后，文件变成35K，开了auto_vacuum之后是36K。

变化不大，无所谓。

但是第二个方法同样有缺点，只会从数据库文件中截断空闲列表中的页， 而不会回收数据库中的碎片，也不会像VACUUM 命令那样重新整理数据库内容。实际上，由于需要在数据库文件中移动页， auto-vacuum 会产生更多的碎片。而且，在执行删除操作的时候，也有那个.db-journal文件产生。

要使用auto-vacuum，需要一些前题条件。 数据库中需要存储一些额外的信息以记录它所跟踪的每个数据库页都找回其指针位置。 所以，auto-vacumm 必须在建表之前就开启。在一个表创建之后， 就不能再开启或关闭 auto-vacumm。

其实按照运行时间上的比较，两个在做了大删除操作后，从3M变到35K的时间其实差不多，执行VACUUM命令稍微长一点，但是也长不了多少，相对而言，这种一点点的长可以忽略不计。

加上AUTO的方式对碎片的造成情况，如果数据交换次数多的话，这种方式很不合适。

Q: 在Windows10上使用git clone代码的时候抛出了异常，重试了几次都是相同的错误：下载的目录里除了.git没有任何东西。

A: 源代码是在linux上编写的，但是在Windows10上拉取代码却出现了问题。根据提示可以看出代码clone是成功的，但是checkout的时候出现了错误。那么问题很可能是不通系统下文件属性或策略导致的。

然后在Git文档上找到一个关于NTFS保护机制的配置，core.protectNTFS：

If set to true, do not allow checkout of paths that would cause problems with the NTFS filesystem, e.g. conflict with 8.3 “short” names. Defaults to true on Windows, and false elsewhere.

Windows系统下默认值是true，也就是说不符合NTFS策略的文件不会被签出，设置为false后可以关闭保护机制。

1

git config core.protectNTFS false

下面是一个完整的示例，展示了如何在ES5环境中使用CustomEvent polyfill来触发自定义事件：

Jekyll timezone 配置有坑，统一使用utc时间

1
2
3
4

$ sh add.sh "timezone issue"
2024-07-01 01:25:49
./_posts/2024-07-01-timezone issue.md
Added successfully

原先我为了成为一个软件工程师而建立这份简单的学习主题清单， 但这份清单随着时间的推移而膨胀成今天这样。在做完这份清单上的每个目标后，我成为了 Amazon 的软件开发工程师! 你或许不需要像我一样学习这么多。但是，让你成为一位称职工程师所需要的知识都在这里了。

我每天自学8~12小时，这样持续了好几个月。这是我的故事：为什么我为了 Google 面试而自学了8个月。

请注意: 你不需要像我一样那么努力学习。我在一些不必要的事情上浪费了很多时间。关于这个问题下面有更多信息。我会帮助你节省宝贵的时间，让你达到目标。 在这份清单内的主题会让你拥有足够的知识去面对几乎每家软件公司的技术面试，包括科技巨头：Amazon、Facebook、Google，以及 Microsoft。

祝你好运!

怎么开始使用？

• Q:这个开源库要怎么开始使用？https://github.com/tesseract-ocr/tesseract

• A:要开始使用Tesseract OCR开源库，您需要经过以下几个步骤：

  1. 下载与安装Tesseract
  • 访问Tesseract的GitHub页面: https://github.com/tesseract-ocr/tesseract
  • 根据您的操作系统选择合适的安装方法。对于Windows用户，您可以直接下载预编译的可执行文件，通常推荐从UB Mannheim的发布页面下载稳定版本：Tesseract Releases
    1. 设置环境变量
  • 添加Tesseract可执行文件的路径到系统的PATH环境变量中，以便在命令行任何位置调用tesseract命令。
  • 同样，需要设置TESSDATA_PREFIX环境变量指向包含tessdata文件夹的路径，该文件夹内存储了语言数据包
    1. 安装语言数据包
  • Tesseract需要相应的语言数据包才能进行识别。您可以从这里下载所需的语言包（.traineddata文件）。
  • 将下载的.traineddata文件放置到/tessdata目录下。例如，对于英文识别，您需要eng.traineddata。
    1. 测试安装
  • 打开命令提示符或终端，输入 tesseract –version 来确认Tesseract已成功安装及其版本信息。
  • 运行 tesseract –list-langs 来查看已安装的语言包列表。
    1. 使用Tesseract进行识别
  • 基本命令格式为：tesseract [-l ] 是您要识别的图片文件路径。 是输出文本文件的名称。 -l 是指定识别的语言，默认为英文。
    1. 在C#项目中集成Tesseract 要在C#项目中使用Tesseract，您可以使用第三方封装库，如Tesseract.SPI或Tesseract。首先，在Visual Studio中打开您的项目，然后通过NuGet包管理器安装这些库之一。 Install-Package Tesseract -Version 4.1.1 接着，按照前面提到的C#示例代码来调用Tesseract进行OCR识别。

通过以上步骤，您就可以开始在您的项目中使用Tesseract OCR进行文字识别了。记得根据实际需求调整配置以优化识别效果。

test

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

D:\Tesseract-OCR>tesseract.exe --version
tesseract v5.4.0.20240606
 leptonica-1.84.1
  libgif 5.2.1 : libjpeg 8d (libjpeg-turbo 3.0.1) : libpng 1.6.43 : libtiff 4.6.0 : zlib 1.3 : libwebp 1.4.0 : libopenjp2 2.5.2
 Found AVX512BW
 Found AVX512F
 Found AVX512VNNI
 Found AVX2
 Found AVX
 Found FMA
 Found SSE4.1
 Found libarchive 3.7.4 zlib/1.3.1 liblzma/5.6.1 bz2lib/1.0.8 liblz4/1.9.4 libzstd/1.5.6

D:\Tesseract-OCR>tesseract --version
tesseract v5.4.0.20240606
 leptonica-1.84.1
  libgif 5.2.1 : libjpeg 8d (libjpeg-turbo 3.0.1) : libpng 1.6.43 : libtiff 4.6.0 : zlib 1.3 : libwebp 1.4.0 : libopenjp2 2.5.2
 Found AVX512BW
 Found AVX512F
 Found AVX512VNNI
 Found AVX2
 Found AVX
 Found FMA
 Found SSE4.1
 Found libarchive 3.7.4 zlib/1.3.1 liblzma/5.6.1 bz2lib/1.0.8 liblz4/1.9.4 libzstd/1.5.6

D:\Tesseract-OCR>tesseract --list-langs
List of available languages in "D:\Tesseract-OCR/tessdata/" (7):
chi_sim
chi_sim_vert
chi_tra
chi_tra_vert
eng
enm
osd

D:\Tesseract-OCR>tesseract D:\Tesseract-OCR\input\test.png test.txt -l eng

D:\Tesseract-OCR>tesseract D:\Tesseract-OCR\input\testforchs.png D:\Tesseract-OCR\output\testforchs -l chi_sim

在Window窗體程式開發的時候，如果使用多執行緒程式設計，在子執行緒中訪問主執行緒窗體內的控制元件，就需要使用控制元件的Control.Invoke方法或者BeginInvoke方法。但是有時候因為Window執行速度太快，尤其是你寫程式碼的時候在InitializeComponent();完成之前起了一個執行緒去執行某些操作，涉及到窗體控制元件的，當你在呼叫Control.Invoke的時候，就可能出現 “在建立視窗控制代碼之前，不能在控制元件上呼叫 Invoke 或 BeginInvoke

解決的辦法就是讓執行緒等待，直到視窗控制代碼建立完畢：

1
2
3
4
5
6
7
8
9

while (!this.IsHandleCreated) 
{ 
    ; 
} 
this.BeginInvoke(new ProListIndexChangedDelegate(GetProLyric));

//根據不同情況也可以： 
if (this.IsHandleCreated) 
BeginInvoke(new ProListIndexChangedDelegate(GetProLyric));

有一個更巧妙的方法，只要在BeginInvoke方法的呼叫語句前再加一句：IntPtr i = this.Handle;就OK了，這比死迴圈配合this.IsHandleCreated的判斷方法更簡潔，因為this.Handle這個屬性本身就對應一個方法，取不到控制代碼，程式就不會向下進行。