Welcome to System.Text.Json - How to read & write .NET objects as JSON

System.Text.Json: Reading & Writing .NET Objects as JSON

This document provides a comprehensive note on the YouTube video "Welcome to System.Text.Json - How to read & write .NET objects as JSON" from the dotnet channel.

---

1. Summary

The video introduces `System.Text.Json`, a high-performance, built-in .NET library for serializing and deserializing .NET objects to and from JSON. It emphasizes the library's focus on performance and low memory allocation, along with its native UTF-8 support. The presenters, James and Matt, demonstrate the fundamental operations of writing .NET objects to JSON strings and files, as well as reading JSON strings and files back into .NET objects. The video also briefly touches upon the Document Object Model (DOM) for in-memory JSON manipulation.

---

2. Key Takeaways

* **`System.Text.Json`**: A modern, built-in .NET library for JSON serialization and deserialization, designed for high performance and low memory usage.

* **Serialization**: The process of converting a .NET object's state (property values) into a JSON format for storage or transmission.

* **Deserialization**: The process of reconstructing a .NET object from a JSON format.

* **Performance Focus**: `System.Text.Json` prioritizes speed and memory efficiency over an exhaustive feature set.

* **UTF-8 Support**: Built-in support for UTF-8 encoding optimizes reading and writing JSON, which is prevalent on the web and in files.

* **In-Memory DOM**: The library offers a Document Object Model (DOM) for random access to JSON elements within a string or file.

* **Key Classes**: `JsonSerializer` is the primary class for performing serialization and deserialization.

* **Async Operations**: While not always strictly required for basic operations, async file I/O should be considered for better responsiveness.

---

3. Detailed Notes

#### 00:00 - Intro & What is JSON and System.Text.Json?

* **What is JSON?**

* JavaScript Object Notation.

* A lightweight data-interchange format.

* Easy for humans to read and write.

* Easy for machines to parse and generate.

* Commonly used for data transmission on the web.

* **What is Serialization?**

* The process of converting the state of an object (property values) into a form that can be stored or transmitted.

* Does not include methods.

* **What is Deserialization?**

* Reconstructing an object from its serialized form.

* **`System.Text.Json`**:

* A new, built-in library in .NET (introduced in .NET Core 3.0 and enhanced since).

* Designed for **high performance** and **low memory allocation**.

* Almost every .NET app can utilize it.

* **Built-in UTF-8 support**: Optimizes reading and writing JSON encoded as UTF-8, the standard for web and file data.

* Also provides classes for working with an **in-memory document object model (DOM)**, allowing random access to JSON elements.

#### 03:00 - Writing/Serializing .NET Objects as JSON

* **Core Class**: `System.Text.Json.JsonSerializer`

* **Method**: `JsonSerializer.Serialize()`

* **Process**:

1. Define a .NET class with properties.

2. Create an instance of that class and populate its properties.

3. Call `JsonSerializer.Serialize()` with the object instance as the argument.

4. The method returns a JSON string representing the object.

* **Example**:

```csharp

public class Person

{

public string Name { get; set; }

public int Age { get; set; }

}

var person = new Person { Name = "Alice", Age = 30 };

string jsonString = JsonSerializer.Serialize(person);

// jsonString will be: {"Name":"Alice","Age":30}

```

* **Naming Conventions**: By default, property names in JSON will match the .NET property names (case-sensitive). Options exist to customize this (e.g., camelCase).

#### 07:40 - Writing JSON Data to a File

* **Using `StreamWriter` (or similar)**:

1. Obtain the JSON string using `JsonSerializer.Serialize()`.

2. Use `System.IO.File.WriteAllText()` to write the string to a file.

* **Using `FileStream` and `StreamWriter`**:

1. Create a `FileStream` for the desired file path.

2. Create a `StreamWriter` wrapping the `FileStream`.

3. Call `JsonSerializer.Serialize()` and pass the `StreamWriter` to it. (This is a more efficient way as it avoids creating an intermediate string).

* **Example (Direct to Stream)**:

```csharp

using (var stream = File.Create("person.json"))

using (var writer = new Utf8JsonWriter(stream)) // Or directly serialize to a stream

{

JsonSerializer.Serialize(writer, person);

}

```

* **Correction (00:17:18)**: The video briefly mentions async here. For file I/O, using async operations (`StreamWriter.WriteAsync`, `File.WriteAllTextAsync`) is generally recommended for non-blocking operations, especially in UI applications or high-concurrency scenarios. The correction states async isn't strictly required for this simple example, but good practice to consider.

#### 12:05 - Reading/Deserializing JSON as .NET Objects

* **Core Class**: `System.Text.Json.JsonSerializer`

* **Method**: `JsonSerializer.Deserialize<T>()` where `T` is the target .NET type.

* **Process**:

1. Have a JSON string.

2. Call `JsonSerializer.Deserialize<YourClass>()` passing the JSON string.

3. The method returns an instance of `YourClass` populated with data from the JSON.

* **Example**:

```csharp

string jsonString = "{\"Name\":\"Bob\",\"Age\":25}";

Person person = JsonSerializer.Deserialize<Person>(jsonString);

// person.Name will be "Bob", person.Age will be 25

```

* **Type Matching**: Property names in the JSON are matched to property names in the .NET object (case-insensitive by default, but configurable). The types of the values should be compatible.

#### 15:05 - Reading a JSON File to a .NET Object

* **Using `File.ReadAllText()`**:

1. Read the entire content of the JSON file into a string using `System.IO.File.ReadAllText()`.

2. Pass this string to `JsonSerializer.Deserialize<YourClass>()`.

* **Using `FileStream` and `StreamReader`**:

1. Create a `FileStream` to open the JSON file.

2. Create a `StreamReader` wrapping the `FileStream`.

3. Call `JsonSerializer.Deserialize<YourClass>()` passing the `StreamReader` or stream. This is more memory-efficient for large files as it doesn't load the entire file into memory at once.

* **Example (Stream)**:

```csharp

using (var stream = File.OpenRead("person.json"))

{

Person person = JsonSerializer.Deserialize<Person>(stream);

}

```

* **Async Operations**: Again, for file reading, consider `File.ReadAllTextAsync` or `StreamReader.ReadToEndAsync` for asynchronous operations.

#### 19:00 - Wrap-up and What's Next

* Recap of the basic serialize/deserialize operations.

* Emphasis on the performance benefits of `System.Text.Json`.

* Mention of the existence of `JsonDocument` and `JsonElement` for DOM-based access.

* The video is part of a larger playlist on JSON serialization with `System.Text.Json`.

* Encouragement to explore the provided documentation links for more advanced features and details.

* Links to other .NET resources like beginner videos, certifications, blogs, and community forums.