创建目录

```bash
mkdir cesium-vite-test
cd cesium-vite-test/
```

创建 package.json


```bash
yarn init -y
```

安装依赖

```bash
yarn add -D cesium vite vite-plugin-cesium
```

由于 Cesium 不是一个普通的 npm 包，需要依赖一些 css ，图片，json 啥的。我们要参考 [Cesium 官方的 webpack 教程](https://link.zhihu.com/?target=https%3A//cesium.com/docs/tutorials/cesium-and-webpack/) 来做一堆额外的工作。 值得庆幸的是现在 Vite 有了 [vite-plugin-cesium](https://link.zhihu.com/?target=https%3A//github.com/nshen/vite-plugin-cesium) 插件，来帮我们完成这些配置。

创建 `vite.config.js`

```js
import { defineConfig } from 'vite';
import cesium from 'vite-plugin-cesium'; // 引入插件
export default defineConfig({
    plugins: [cesium()],
});
```

在 `package.json` 中加入 `dev` 和 `build` 命令

```json
"scripts": {
    "dev": "vite",
    "build": "vite build"
},
```

配置完成分割线。

------

可以开始写代码开发了。

```
src/index.js
import { Viewer } from 'cesium';
import "./css/main.css";

const viewer = new Viewer('cesiumContainer');
index.html
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>cesium-vite</title>
    <script type="module" src="/src/index.js"></script>
</head>

<body>
    <div id="cesiumContainer"></div>
</body>

</html>
src/css/main.css
html, body, #cesiumContainer {
    width: 100%;
    height: 100%;
    margin: 0;
    padding: 0;
    overflow: hidden;
}
```

运行 `yarn dev` ，哒哒完成。

一分钟搭建 Vite + Cesium 开发环境

我的世界server.properties配置文件详解

![使用Linux搭建Terraria服务器，详细步骤](https://picx.zhimg.com/v2-cd4d871c9e284581038f6597ffac79ed_720w.jpg?source=172ae18b)


## 第一步 防火墙设置


因为terraria默认服务器端口7777，所以添加该端口白名单

华为云使用的是安全组，未使用防火墙，我这里在控制台添加了端口，其他服务商可能不同。

![img](https://pic3.zhimg.com/80/v2-0d3b8c0178218626727568b787b75ffe_1440w.webp)

------

## 第二步 安装准备

- 安装screen与unzip

```text
yum install screen unzip
```

- 下载服务端

```text
mkdir terraria
cd terraria
wget http://terraria.org/server/terraria-server-1353.zip
```

各版本下载地址都在[Terraria wiki](https://link.zhihu.com/?target=https%3A//terraria.gamepedia.com/Server%23Downloads)上，也可以直接修改url切换版本

![img](https://pic1.zhimg.com/80/v2-3c22c4da8347906a7be3116348e349f8_1440w.webp)

- 解压

```text
unzip terraria-server-1353.zip
```

------

## 第三步 运行服务端

- 创建并进入名叫tr的screen

```text
screen -S tr
```

screen 可使用ctrl+a+d保持会话退出，下次进入可以通过 screen -r tr 返回

- 移动至Linux 服务端文件夹并运行对应版本

TerrariaServer.bin.x86_64 和 TerrariaServer.bin.x86 分别对应64位和32位

```text
cd 1353/Linux/
./TerrariaServer.bin.x86_64
```

如果遇到Permission denied话则是权限不足，考虑修改目录权限

```text
sudo chmod -R 777  /root/terraria/1353/Linux
```

------

## 第四步 服务器配置

如果TerrariaServer.bin.x86_64可以运行，则只需要进行简单配置便可以启动服务

我这里把大概流程选项发一下：

```text
Terraria Server v1.3.5.3

n       New World
d <number>Delete World

Choose World: 
```

选择世界：输入数字选择已有世界、n为创建新世界、d+数字为删除对应编号的世界。目前无已有世界，我这里输入n选择创建新世界。

```text
Terraria Server v1.3.5.3

1       Small
2       Medium
3       Large

Choose size: 
```

选择世界大小，输入数字1，2，3发别对应着小世界，中世界，大世界

```text
Terraria Server v1.3.5.3

1       Normal
2       Expert

Choose difficulty: 
```

选择世界难度，1普通难度，2专家难度

```text
Terraria Server v1.3.5.3

Enter world name: 
```

输入世界名称：我这里输入了Deep Dark Fantasy

在输入完世界名称后便会开始创建世界，创建成功后会回到选择世界界面

```text
Terraria Server v1.3.5.3

1               Deep Dark Fantasy
2               easy
n       New World
d <number>Delete World

Choose World: 
```

输入1，选择世界 Deep Dark Fantasy，接下下来会有4个选项，分别为：

```text
 Max players (press enter for 8):
```

最大人数，默认8

```text
Server port (press enter for 7777):
```

服务端口，默认7777

```text
Automatically forward port? (y/n): 
```

自动转发端口？默认y

```text
Server password (press enter for none): 
```

服务器密码，默认无

全部填写完毕，等待服务器加载，出现以下界面则说明启动成功，使用ctrl+a+d可退出screen

![img](https://pic3.zhimg.com/80/v2-24d810a0ee2a063bb392679d1ff59596_1440w.webp)

启动成功

启动terraria→选择多人游戏→通过ip加入→输入外网ip→输入端口号→选择角色→进入游戏

![img](https://pic3.zhimg.com/80/v2-263295a6fc876b8c05e7a4dc8acb73d6_1440w.webp)

加入服务器成功

加入服务器成功，Welcome to Deep Dark Fantasy!

～～～～～～～～～～～～～～～～～～～～

关于terraria服务器第一次加入能够成功，退出之后不能再次加入的bug：

当目前游戏人数达到了服务器配置的最大人数，游戏玩家退出后将不能再次加入服务器，可以将服务器最大人数设置的稍高一点，以免触发bug。

使用Linux搭建Terraria服务器，详细步骤

最近在做接口开发，对方团队开发了一个`Web API`的接口，传输数据的格式是`JSON`。当时看到这个东西，感觉很简单，也没想什么，没用多久就完成了我的功能，我完成的功能很简单，就是获取数据，然后把数据列表进行`JSON`序列化，然后再以`POST`方式调用对方`Web Api`的接口，将`JSON`的数据一起传递过去，我想的很简单，直接调用并返回结果就完成了。最后对方接口返回错误，提示从传递过去的`JSON`数据中的第一个字段开始就取不到值。



　　郁闷，为什么呢？我的参数也是按着他们接口的规范写的，数据获取也没错，`JSON`格式化的数据好像也正常，对方团队的`Api`接口为什么提示取不到值。后来，静下心来，仔细看了看我的项目，应该没啥大问题。突然，好像感觉找到了原因，但是感觉不应该是这个问题，那就是我传递的`JSON`数据的`Key`值的名称采用的是`Pascal`命名法，就是每个单词的首字符都是大写的（`{“BoyFirend”:“xxx”,"HomeAddress":"xxxx"}`），而对方的`Key`的命名法是`Camel`命名法（比如：`{“boyFirend”:“xxx”,"homeAddress":"xxxx"}`）。之所以产生这个结果，因为`JSON`数据是直接通过`C#`的实体类序列化而来的，在`C#` 中的实体类的每个属性的命名就是采用的是`Pascal`命名方法。找到了原因，但是不太确定，然后一试，还真是这个原因。

　　原因找到了，解决问题就简单了，对方团队写的`Api`接口个人感觉兼容不好，不应该对大小写敏感，让接口更通用一点才好，我建议对方改一下接口，对方好像不怎么同意，那我只能修改我的接口了。说到`JSON`序列化，我使用的是`Newtonsoft.Json`。

## 一、Newtonsoft.Json介绍

　　做`Web`开发的，没有接触过`JavaScript`的肯定很少，做前端开发，没有接触过`Ajax`的估计更不多了。现在的系统大多数是分布式系统，分布式系统就会涉及到数据的传输，`JSON`在数据传输和提交方面有着天生的优势。当我们使用`Json`的时候，很多时候会涉及到几个序列化对象的使用：`DataContractJsonSerializer`、`JavaScriptSerializer` 和[Json.NET](https://www.newtonsoft.com/json)即`Newtonsoft.Json`。大多数人都会选择性能以及通用性较好`Json.NET`，这个不是微软的类库，是一个开源的`Json`操作类库，速度比`DataContractJsonSerializer`快50%，比`JavaScriptSerializer`快250%，从下面的性能对比就可以看到它的性能优点。

　　![img](https://images0.cnblogs.com/i/8867/201404/282228152051648.png)

　　它的确很快，使用也很简单，它支持序列化的对象也很多，我刚开始以为只是支持以实体类为基础的序列化，其实还有很多，比如：数据表（DataTable）、数据集（DataSet）等，你了解越深就越喜欢它，也避免你在不知的情况下“重复造轮子”。

## 二、基本用法

　　Json.Net是支持序列化和反序列化`DataTable,DataSet,Entity Framework`和`Entity`的。下面分别举例说明序列化和反序列化。

**DataTable：**

```c
//序列化DataTable
DataTable dt = new DataTable();
dt.Columns.Add("Age", Type.GetType("System.Int32"));
dt.Columns.Add("Name", Type.GetType("System.String"));
dt.Columns.Add("Sex", Type.GetType("System.String"));
dt.Columns.Add("IsMarry", Type.GetType("System.Boolean"));
for (int i = 0; i < 4; i++)
{
    DataRow dr = dt.NewRow();
    dr["Age"] = i + 1;
    dr["Name"] = "Name" + i;
    dr["Sex"] = i % 2 == 0 ? "男" : "女";
    dr["IsMarry"] = i % 2 > 0 ? true : false;
    dt.Rows.Add(dr);
}
Console.WriteLine(JsonConvert.SerializeObject(dt));
```

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/281443553617087.png)

　　利用上面字符串进行反序列化

```c
string json = JsonConvert.SerializeObject(dt);
dt = JsonConvert.DeserializeObject<DataTable>(json);
foreach (DataRow dr in dt.Rows)
{
    Console.WriteLine("{0}\\t{1}\\t{2}\\t{3}\\t", dr[0], dr[1], dr[2], dr[3]);
}
```

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/281448403619018.png)

　　`Entity`序列化和`DataTable`一样，就不过多介绍了。

## 三、高级用法

1. 忽略某些属性
2. 默认值的处理
3. 空值的处理
4. 支持非公共成员
5. 日期处理
6. 自定义序列化的字段名称
7. 动态决定属性是否序列化
8. 枚举值的自定义格式化问题
9. 自定义类型转换
10. 全局序列化设置

### 1.忽略某些属性

　　我们在序列化的过程中，并不是所有属性都需要序列化的，如果实体中有些属性不需要序列化，可以使用该特性。首先介绍`Json.Net`序列化的模式：`OptOut`和`OptIn`

| 模式   | 说明                                                         |
| ------ | ------------------------------------------------------------ |
| OptOut | 默认值，类中所有公有成员会被序列化，如果不想被序列化，可以用特性`JsonIgnore` |
| OptIn  | 默认情况下，所有的成员不会被序列化，类中的成员只有标有特性`JsonProperty`的才会被序列化，当类的成员很多，但客户端仅仅需要一部分数据时，很有用 |

　　**仅需要姓名属性**

```c
[JsonObject(MemberSerialization.OptIn)]
public class Person
{
 public int Age { get; set; }
 [JsonProperty]
 public string Name { get; set; }
 public string Sex { get; set; }
 public bool IsMarry { get; set; }
 public DateTime Birthday { get; set; }
}
```

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/281508379087828.png)

　　**不需要是否结婚属性**

```c
[JsonObject(MemberSerialization.OptOut)]
public class Person
{
    public int Age { get; set; }
    public string Name { get; set; }
    public string Sex { get; set; }
    [JsonIgnore]
    public bool IsMarry { get; set; }
    public DateTime Birthday { get; set; }
}
```

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/281510410171151.png)

　　 通过上面的例子可以看到，要实现不返回某些属性的需求很简单：

1. 在实体类上加上`[JsonObject(MemberSerialization.OptOut)]`
2. 在不需要返回的属性上加上`[JsonIgnore]`说明。

### 2.默认值处理

　序列化时想忽略默认值属性可以通过`JsonSerializerSettings.DefaultValueHandling`来确定，该值为枚举值

| 枚举值                       | 说明                           |
| ---------------------------- | ------------------------------ |
| DefaultValueHandling.Ignore  | 序列化和反序列化时，忽略默认值 |
| DefaultValueHandling.Include | 序列化和反序列化时，包含默认值 |

```c
[DefaultValue(10)]
public int Age { get; set; }

Person p = new Person
{
    Age = 10,
    Name = "张三丰",
    Sex = "男",
    IsMarry = false,
    Birthday = new DateTime(1991, 1, 2)
};
JsonSerializerSettings jsetting = new JsonSerializerSettings();
jsetting.DefaultValueHandling = DefaultValueHandling.Ignore;
Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));
```

　　最终结果如下：

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/290700436652801.png)

### 3.空值的处理

序列化时需要忽略值为`NULL`的属性，可以通过`JsonSerializerSettings.NullValueHandling`来确定，另外通过`JsonSerializerSettings`设置属性是对序列化过程中所有属性生效的，想单独对某一个属性生效可以使用`JsonProperty`，下面将分别展示两个方式

　　**1）JsonSerializerSettings**

```c
Person p = new Person
{
    room = null,
    Age = 10,
    Name = "张三丰",
    Sex = "男",
    IsMarry = false,
    Birthday = new DateTime(1991, 1, 2)
};
JsonSerializerSettings jsetting = new JsonSerializerSettings();
jsetting.NullValueHandling = NullValueHandling.Ignore;
Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));
```

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/290707560092150.png)

　　**2）JsonProperty**

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/290710397909914.png)

　　通过`JsonProperty`属性设置的方法，可以实现某一属性特别处理的需求，如默认值处理，空值处理，自定义属性名处理，格式化处理。上面空值处理实现

```c
[JsonProperty(NullValueHandling = NullValueHandling.Ignore)]
public Room room { get; set; }
```

### 4.支持非公共成员

　　序列化时默认都是处理公共成员，如果需要处理非公共成员，就要在该成员上加特性`[JsonProperty]`

```c
[JsonProperty]
private int Height { get; set; }
```

### 5.日期处理

　　对于`Dateime`类型日期的格式化就比较麻烦了，系统自带的会格式化成`iso`日期标准`"Birthday":"1991-01-02T00:00:00`，但是实际使用过程中大多数使用的可能是`yyyy-MM-dd`或者`yyyy-MM-dd HH:mm:ss`两种格式的日期，解决办法是可以将`DateTime`类型改成`string`类型自己格式化好，然后再序列化。如果不想修改代码，可以采用下面方案实现。

　　Json.Net提供了`IsoDateTimeConverter`日期转换这个类，可以通过`JsnConverter`实现相应的日期转换

```c
[JsonConverter(typeof(IsoDateTimeConverter))]
public DateTime Birthday { get; set; }
```

　　但是`IsoDateTimeConverter`日期格式不是我们想要的，我们可以继承该类实现自己的日期

```c
public class ChinaDateTimeConverter : DateTimeConverterBase
{
    private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd" };
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return dtConverter.ReadJson(reader, objectType, existingValue, serializer);
    }
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        dtConverter.WriteJson(writer, value, serializer);
    }
}
```

　　自己实现了一个`yyyy-MM-dd`格式化转换类，可以看到只是初始化`IsoDateTimeConverter`时给的日期格式为`yyyy-MM-dd`即可，下面看下效果

```c
[JsonConverter(typeof(ChinaDateTimeConverter))]
public DateTime Birthday { get; set; }
```

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/290750116036578.png)

　　可以根据自己需求实现不同的转换类

### 6.自定义序列化的字段名称

　　实体中定义的属性名可能不是自己想要的名称，但是又不能更改实体定义，这个时候可以自定义序列化字段名称。

```c
[JsonProperty(PropertyName = "CName")]
public string Name { get; set; }
```

### 7.动态决定属性是否序列化

　　根据某些场景，可能`A`场景输出`A`，`B`，`C`三个属性，`B`场景输出`E`，`F`属性。虽然实际中不一定存在这种需求，但是`json.net`依然可以支持该特性。

　　继承默认的`DefaultContractResolver`类，传入需要输出的属性

重写修改了一下，大多数情况下应该是要排除的字段少于要保留的字段, 为了方便书写这里修改了构造函数加入`retain`表示`props`是需要保留的字段还是要排除的字段

```c
public class LimitPropsContractResolver : DefaultContractResolver
{
    string[] props = null;
    bool retain;
    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="props">传入的属性数组</param>
    /// <param name="retain">true:表示`props`是需要保留的字段`false`：表示`props`是要排除的字段</param>
    public LimitPropsContractResolver(string[] props, bool retain = true)
    {
        //指定要序列化属性的清单
        this.props = props;
        this.retain = retain;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> list = base.CreateProperties(type, memberSerialization); //只保留清单有列出的属性
        return list.Where(p =>
        {
            if (retain)
            {
                return props.Contains(p.PropertyName);
            }
            else
            {
                return !props.Contains(p.PropertyName);
            }
        }).ToList();
    }
}
public int Age { get; set; }
[JsonIgnore]
public bool IsMarry { get; set; }
public string Sex { get; set; }

JsonSerializerSettings jsetting = new JsonSerializerSettings();
jsetting.ContractResolver = new LimitPropsContractResolver(new string[] { "Age", "IsMarry" });
Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));
```

　　使用自定义的解析类，只输出`Age`、`IsMarry`两个属性，看下最终结果。只输出了`Age`属性，为什么`IsMarry`属性没有输出呢，因为标注了`[JsonIgnore]`

　　![img](https://images0.cnblogs.com/blog2015/336693/201506/292128345097430.png)

　　看到上面的结果想要实现`pc`端序列化一部分，手机端序列化另一部分就很简单了吧，我们改下代码实现一下

```c
string[] propNames = null; 
if (p.Age > 10)
{
    propNames = new string[] { "Age", "IsMarry" };
}
else
{
    propNames = new string[] { "Age", "Sex" };
}
jsetting.ContractResolver = new LimitPropsContractResolver(propNames);
Console.WriteLine(JsonConvert.SerializeObject(p, Formatting.Indented, jsetting));
```

### 8.枚举值的自定义格式化问题

　　默认情况下对于实体里面的枚举类型系统是格式化成改枚举对应的整型数值，那如果需要格式化成枚举对应的字符怎么处理呢？`Newtonsoft.Json`也帮我们想到了这点，下面看实例

```c
public enum NotifyType
{
    /// <summary>
    /// Emil发送
    /// </summary>
    Mail = 0,
    /// <summary>
    /// 短信发送
    /// </summary>
    SMS = 1
}
public class TestEnmu
{
    /// <summary>
    /// 消息发送类型
    /// </summary>    
    public NotifyType Type { get; set; }
}
JsonConvert.SerializeObject(new TestEnmu());
```

　　输出结果：![img](https://images2015.cnblogs.com/blog/336693/201509/336693-20150910171743028-388882267.png)

　　现在改造一下，输出`"Type":"Mail"`

```c
public class TestEnmu
{
    /// <summary>
    ///消息发送类型
    /// </summary>
    [JsonConverter(typeof(StringEnumConverter))]
    public NotifyType Type { get; set; }
}
```

　　其它的都不变，在`Type`属性上加上了`JsonConverter(typeof(StringEnumConverter))`表示将枚举值转换成对应的字符串，而`StringEnumConverter`是`Newtonsoft.Json`内置的转换类型，最终输出结果

![img](https://images2015.cnblogs.com/blog/336693/201509/336693-20150910172109044-1714459886.png)

### 9.自定义类型转换

　　默认情况下对于实体里面的`Boolean`系统是格式化成`true`或者`false`，对于`true`转成"是" `false`转成"否"这种需求改怎么实现了？我们可以自定义类型转换实现该需求，下面看实例

```c
public class BoolConvert : JsonConverter
{
    private string[] arrBString { get; set; }

    public BoolConvert()
    {
        arrBString = "是,否".Split(',');
    }

    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="BooleanString">将`bool`值转换成的字符串值</param>
    public BoolConvert(string BooleanString)
    {
        if (string.IsNullOrEmpty(BooleanString))
        {
            throw new ArgumentNullException();
        }
        arrBString = BooleanString.Split(',');
        if (arrBString.Length != 2)
        {
            throw new ArgumentException("BooleanString格式不符合规定");
        }
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        bool isNullable = IsNullableType(objectType);
        Type t = isNullable ? Nullable.GetUnderlyingType(objectType) : objectType;
        if (reader.TokenType == JsonToken.Null)
        {
            if (!IsNullableType(objectType))
            {
                throw new Exception(string.Format("不能转换null value to {0}.", objectType));
            }
            return null;
        }
        try
        {
            if (reader.TokenType == JsonToken.String)
            {
                string boolText = reader.Value.ToString();
                if (boolText.Equals(arrBString[0], StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }
                else if (boolText.Equals(arrBString[1], StringComparison.OrdinalIgnoreCase))
                {
                    return false;
                }
            }
            if (reader.TokenType == JsonToken.Integer)
            {
                return Convert.ToInt32(reader.Value) == 1;
            }
        }
        catch (Exception ex)
        {
            throw new Exception(string.Format("Error converting value {0} to type '{1}'", reader.Value, objectType));
        }
        throw new Exception(string.Format("Unexpected token {0} when parsing enum", reader.TokenType));
    }

    /// <summary>
    /// 判断是否为`Bool`类型
    /// </summary>
    /// <param name="objectType">类型</param>
    /// <returns>为`bool`类型则可以进行转换</returns>
    public override bool CanConvert(Type objectType)
    {
        return true;
    }

    public bool IsNullableType(Type t)
    {
        if (t == null)
        {
            throw new ArgumentNullException("t");
        }
        return (t.BaseType.FullName == "System.ValueType" && t.GetGenericTypeDefinition() == typeof(Nullable<>));
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        if (value == null)
        {
            writer.WriteNull(); return;
        }
        bool bValue = (bool)value; if (bValue)
        {
            writer.WriteValue(arrBString[0]);
        }
        else
        {
            writer.WriteValue(arrBString[1]);
        }
    }
}
```

　　自定义了`BoolConvert`类型，继承自`JsonConverter`。构造函数参数`BooleanString`可以让我们自定义将`true false`转换成相应字符串。下面看实体里面怎么使用这个自定义转换类型

```c
public class Person
{
    [JsonConverter(typeof(BoolConvert))]
    public bool IsMarry { get; set; }
}
```

　　![img](https://images2015.cnblogs.com/blog/336693/201512/336693-20151214101004068-161668511.png)‘

　　相应的有什么个性化的转换需求，都可以使用自定义转换类型的方式实现。

### 10.全局序列化设置

　　文章开头提出了`Null`值字段怎么不返回的问题，相应的在高级用法也给出了相应的解决方案使用`jsetting.NullValueHandling = NullValueHandling.Ignore;`来设置不返回空值。这样有个麻烦的地方，每个不想返回空值的序列化都需设置一下。可以对序列化设置一些默认值方式么？下面将解答

```c
Newtonsoft.Json.JsonSerializerSettings setting = new Newtonsoft.Json.JsonSerializerSettings();
JsonConvert.DefaultSettings = new Func<JsonSerializerSettings>(() => {//日期类型默认格式化处理
    setting.DateFormatHandling = Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;
    setting.DateFormatString = "yyyy-MM-dd HH:mm:ss"; //空值处理
    setting.NullValueHandling = NullValueHandling.Ignore; //高级用法九中的`Bool`类型转换设置
    setting.Converters.Add(new BoolConvert("是，否")); 
    return setting;
});
```

　　这样设置以后，以后使用序列化的地方就不需要单独设置了，个人最喜欢设置的是空值处理这一块。

C# Newtonsoft.Json 高级用法

CentOS 支持 .NET。 本文介绍如何在 CentOS 上安装 .NET。 如果需要在 CentOS Stream 上安装 .NET，请参阅[在 RHEL 和 CentOS Stream 上安装 .NET SDK 或 .NET 运行时](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-rhel)。



如果要开发 .NET 应用，请安装 SDK（包括运行时）。 或者，如果只需运行应用程序，请安装运行时。 如果要安装该运行时，建议安装 ASP.NET Core 运行时，因为它同时包括 .NET 和 ASP.NET Core 运行时。

`dotnet --list-sdks`使用 和 `dotnet --list-runtimes` 命令查看安装了哪些版本。 有关详细信息，请参阅[如何检查是否已安装 .NET](https://learn.microsoft.com/zh-cn/dotnet/core/install/how-to-detect-installed-versions)。

 重要

仅在 x64 体系结构上支持包管理器安装。 对于 Arm 等其他体系结构，必须通过其他一些方式安装 .NET，例如，通过 Snap 和安装程序脚本进行安装，或通过手动提取二进制文件进行安装。

有关在不使用包管理器的情况下安装 .NET 的详细信息，请参阅以下文章之一：

- [或者，通过 Snap 安装 .NET。](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-snap)
- [或者，通过 `install-dotnet` 脚本安装 .NET。](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-scripted-manual#scripted-install)
- [手动安装 .NET](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-scripted-manual#manual-install)

## 支持的分发

下表列出了 CentOS 7 和 CentOS 8 上当前受支持的 .NET 版本。 这些版本在 [.NET 版本达到支持终止日期](https://dotnet.microsoft.com/platform/support/policy/dotnet-core)或 CentOS 版本不再受支持之前仍受支持。

| CentOS | .NET |
| :----- | :--- |
| 7      | 7, 6 |

 警告

*CentOS 8 已于 2021 年 12 月 31 日提前结束生命周期 (EOL)。 有关详细信息，请参阅官方 [CentOS Linux EOL 页](https://www.centos.org/centos-linux-eol/)。 因此，CentOS Linux 8 不支持 .NET 6 及更高版本。

以下 .NET 版本 ❌ 不再受到支持：

- .NET 5
- .NET Core 3.1
- .NET Core 3.0
- .NET Core 2.2
- .NET Core 2.1
- .NET Core 2.0

 重要

仅在 x64 体系结构上支持包管理器安装。 对于 Arm 等其他体系结构，必须通过其他一些方式安装 .NET，例如，通过 Snap 和安装程序脚本进行安装，或通过手动提取二进制文件进行安装。

有关在不使用包管理器的情况下安装 .NET 的详细信息，请参阅以下文章之一：

- [或者，通过 Snap 安装 .NET。](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-snap)
- [或者，通过 `install-dotnet` 脚本安装 .NET。](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-scripted-manual#scripted-install)
- [手动安装 .NET](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-scripted-manual#manual-install)

## 安装预览版本

包管理器中未提供 .NET 的预览版和候选发布版本。 可通过下面其中一种方式安装 .NET 的预览版和候选发布版本：

- [Snap 包](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-snap)
- [使用 install-dotnet.sh 脚本安装](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-scripted-manual#scripted-install)
- [手动提取二进制文件](https://learn.microsoft.com/zh-cn/dotnet/core/install/linux-scripted-manual#manual-install)

## 删除预览版本

使用包管理器管理 .NET 安装时，如果之前安装了预览版本，则可能会遇到冲突。 包管理器可能会将非预览版本解释为 .NET 的较早版本。 若要安装非预览版本，需要首先卸载预览版本。 有关如何卸载 .NET 的详细信息，请参阅[如何删除 .NET 运行时和 SDK](https://learn.microsoft.com/zh-cn/dotnet/core/install/remove-runtime-sdk-versions?pivots=os-linux#uninstall-net)。

## CentOS 7

安装 .NET 之前，请运行以下命令，将 Microsoft 包签名密钥添加到受信任密钥列表，并添加 Microsoft 包存储库。 打开终端并运行以下命令：

Bash

```bash
sudo rpm -Uvh https://packages.microsoft.com/config/centos/7/packages-microsoft-prod.rpm
```

### 安装 SDK

.NET SDK 使你可以通过 .NET 开发应用。 如果安装 .NET SDK，则无需安装相应的运行时。 若要安装 .NET SDK，请运行以下命令：

Bash

```bash
sudo yum install dotnet-sdk-7.0
```

### 安装运行时

通过 ASP.NET Core 运行时，可以运行使用 .NET 开发且未提供运行时的应用。 以下命令将安装 ASP.NET Core 运行时，这是与 .NET 最兼容的运行时。 在终端中，运行以下命令：

Bash

```bash
sudo yum install aspnetcore-runtime-7.0
```

作为 ASP.NET Core 运行时的一种替代方法，你可以安装不包含 ASP.NET Core 支持的 .NET 运行时：将上一命令中的 `aspnetcore-runtime-7.0` 替换为 `dotnet-runtime-7.0`：

Bash

```bash
sudo yum install dotnet-runtime-7.0
```

第一步 防火墙设置

第一步防火墙设置