![使用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
```

在 CentOS 上安装 .NET SDK 或 .NET 运行时

## **一、Cesium影像图层的体系结构**


注：Imagery可以翻译为图像、影像，这里就统一翻译为影像，不是特指卫星影像数据。

**1.1、ImageryProvider类**


**Cesium.ImageryProvider**类及其子类封装了加载各种影像图层的方法，其中Cesium.ImageryProvider类是抽象类、基类或者可将其理解为接口，它不能被直接实例化。

可以将ImageryProvider看作是影像图层的数据源，我们想使用哪种影像图层数据或服务就用对应的ImageryProvider子类去加载。

ImageryProvider类及其子类的体系结构：

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

**1.2、ImageryLayer类**

使用过桌面端GIS产品的同学都知道，一份GIS数据会被组织成图层符号化并渲染，数据相当于内在血液、内脏，信息量丰富，而图层相当于外在皮毛、衣服，用于呈现给外界。

Cesium同样将数据源组织成图层符号化并渲染，**Cesium.ImageryLayer类**就用于表示Cesium中的影像图层，它就相当于皮毛、衣服，将数据源包裹，它需要数据源为其提供内在丰富的地理空间信息和属性信息。

**1.3、ImageryLayerCollection类**

**Cesium.ImageryLayerCollection类**是ImageryLayer类对象的容器，它可以装载、放置多个ImageryLayer类对象，而且它内部放置的ImageryLayer类对象是有序的。

Cesium.Viewer类对象中包含的imageryLayers属性就是ImageryLayerCollection类的实例，它包含了当前Cesium应用程序所有的ImageryLayer类对象，即所有影像图层。

## **二、加载OpenStreetMap影像服务**

笔者最常用的数据就是OSM数据，不管是OSM的矢量数据还是瓦片地图服务，总之用得最勤，那就先来讲讲怎么在Cesium中加载OSM的影像服务。

直接使用OpenStreetMapImageryProvider类加载即可，几行代码就搞定！

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>OSM影像图层</title>
    <script src="https://cesium.com/downloads/cesiumjs/releases/1.65/Build/Cesium/Cesium.js"></script>
    <link href="https://cesium.com/downloads/cesiumjs/releases/1.65/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
</head>
<body>
    <div id="cesium"></div>

    <script>
        // 初始化Cesium应用程序
        const viewer = new Cesium.Viewer('cesium');  
        // 移除默认的影像图层   
        const imageryLayers = viewer.imageryLayers;
        imageryLayers.remove(imageryLayers.get(0));
        
        // 初始化OSM影像图层数据源
        const osmImageryProvider = new Cesium.OpenStreetMapImageryProvider({
            url : 'https://a.tile.openstreetmap.org/'
        });
        // 将OSM影像图层数据源组织为OSM影像图层
        const osmImageryLayer = new Cesium.ImageryLayer(osmImageryProvider);
        // 将OSM影像图层加入到影像图层容器中
        imageryLayers.add(osmImageryLayer);
    </script>
</body>
</html>
```

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

![img](https://pic2.zhimg.com/80/v2-7a177f3197d928e5e5662432af003d45_1440w.webp)

影像服务确切讲应该是指卫星影像数据，但是这里为了方便也叫影像服务，总之它就是瓦片地图。

## **三、使用XYZ方式加载影像服务**

XYZ方式就是根据瓦片服务的瓦片坐标系来加载对应瓦片，瓦片坐标系这里就不赘诉了，总之它有三个维度：

- X、Y表示水平维度的坐标
- Z表示垂直维度的坐标。可以理解为层级，层级越高，比例尺越大，地图分辨率越低（单位像素覆盖的地理范围越小）。

在Cesium中使用**UrlTemplateImageryProvider类**构建XYZ形式URL，去请求对应的影像瓦片。比如可以使用XYZ方式加载上面加载过的OSM影像服务：

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>XYZ方式加载影像图层</title>
    <script src="https://cesium.com/downloads/cesiumjs/releases/1.65/Build/Cesium/Cesium.js"></script>
    <link href="https://cesium.com/downloads/cesiumjs/releases/1.65/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
</head>
<body>
    <div id="cesium"></div>

    <script>
        const viewer = new Cesium.Viewer('cesium');
        const imageryLayers = viewer.imageryLayers;
        imageryLayers.remove(imageryLayers.get(0));
        
        // 使用XYZ方式加载OSM影像服务
        const xyzImageryProvider = new Cesium.UrlTemplateImageryProvider({
            url: 'http://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png',
            subdomains: ['a', 'b', 'c']
        });
        // 将OSM影像数据源组织为OSM影像图层并加入到影像图层容器中
        const xyzImageryLayer = new Cesium.ImageryLayer(xyzImageryProvider);
        imageryLayers.add(xyzImageryLayer);
    </script>
</body>
</html>
```

这里需要注意参数**subdomains**，它表示子域。subdomains参数数组中的四个值可以替换url中的{s}，也就是改变不同的请求URL，从而提高加载数据的速度。

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

![img](https://pic2.zhimg.com/80/v2-e5f04b467b001727acdfd572f04a3f75_1440w.webp)

这就相当于四条道路一起分担人流和车流的压力。

使用XYZ方式加载的OSM影像图层：

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

## **四、加载必应地图的影像服务**

微软旗下的必应地图（Bing Map）是收费的，所以在国内基本没人拿来当WebGIS“**图层三明治**“的底图，不过拿来写示例程序的时候使用还是蛮不错的！

在Cesium中加载Bing Map影像服务和上面加载OSM的影像服务一样简单，直接使用BingMapsImageryProvider类即可。

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>加载Bing Map的影像服务</title>
    <script src="https://cesium.com/downloads/cesiumjs/releases/1.65/Build/Cesium/Cesium.js"></script>
    <link href="https://cesium.com/downloads/cesiumjs/releases/1.65/Build/Cesium/Widgets/widgets.css" rel="stylesheet">
</head>
<body>
    <div id="cesium"></div>

    <script>
        const viewer = new Cesium.Viewer('cesium');
        const imageryLayers = viewer.imageryLayers;
        imageryLayers.remove(imageryLayers.get(0));
        
        // 加载Bing Map影像服务
        var bing = new Cesium.BingMapsImageryProvider({
            url : 'https://dev.virtualearth.net',
            key : 'Bing Map官方提供的个人Key',
            mapStyle : Cesium.BingMapsStyle.AERIAL
        });

        const bingImageryLayer = new Cesium.ImageryLayer(bing);
        imageryLayers.add(bingImageryLayer);
    </script>
</body>
</html>
```

加载Bing Map影像服务需要个人的Key，上面的key参数就是应该填Bing Map官方提供的个人Key，可以直接去Bing Map的官网申请就好，只用于学习和个人用途是不收费的，如果商用就要收费了。

mapStyle这个参数用于指定加载哪种用途，或者说哪种类型的影像服务吧，查看Cesium的官方文档知道可以指定为如下参数：

![img](https://pic2.zhimg.com/80/v2-6234896e78632cd826c0364f6f5b5fad_1440w.webp)

总之这些不同的影像服务就是是否有路网、是否有注记之类的区别，挑选合适的使用就好了。

![img](https://pic2.zhimg.com/80/v2-886def9ea7b3cda5bea877a5ac33a04d_1440w.webp)

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

![img](https://pic2.zhimg.com/80/v2-4b151433dad9152d621c3695631b7f95_1440w.webp)

## **五、加载Cesium Ion中的影像服务**

Cesium自家的Cesium Ion中也包含了许多影像服务，我们同样可以加载它们。

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>加载Cesium Ion中的影像服务</title>
    <script src="http://localhost:8080/cesium/Cesium/Cesium.js"></script>
    <link href="http://localhost:8080/cesium/Cesium/Widgets/widgets.css" rel="stylesheet">
</head>
<body>
    <div id="cesium"></div>

    <script>
        Cesium.Ion.defaultAccessToken = 'Cesium Ion的个人访问Token';
        const viewer = new Cesium.Viewer('cesium');
        const imageryLayers = viewer.imageryLayers;

        // 加载Cesium Ion中asset ID为3812的影像服务
        const ionImageryProvider_3812 = new Cesium.IonImageryProvider({
            assetId: 3812
        });
        // 将影像数据源组织为影像图层
        const blackMarbleLayer = new Cesium.ImageryLayer(ionImageryProvider_3812, {
            alpha: 0.5,
            brightness: 2.0
        });
        imageryLayers.add(blackMarbleLayer);
    </script>
</body>
</html>
```

想加载Cesium Ion中的某个影像服务，只需要在参数assetId填上对应的asset Id即可。

![img](https://pic2.zhimg.com/80/v2-073ba22e4f31a447b3b0d8d5fd40147d_1440w.webp)

Cesium多源数据加载之影像图层

## 一、Cesium4种获取鼠标点击位置


1.获取鼠标点的对应椭球面位置：世界坐标（Cartesian3）

通过 viewer.scene.camera.pickEllipsoid(movement.position, ellipsoid)获取，可以获取当前点击视线与椭球面相交处的坐标，其中ellipsoid是当前地球使用的椭球对象：viewer.scene.globe.ellipsoid。


```javascript
var viewer = new Cesium.Viewer('cesiumContainer');
var handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
handler.setInputAction(function (movement) {
     var position = viewer.scene.camera.pickEllipsoid(movement.position, viewer.scene.globe.ellipsoid);
     console.log(position);
}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
```

2.获取加载地形后对应的经纬度和高程：地标坐标

通过viewer.scene.globe.pick(ray, scene)获取，可以获取点击处地球表面的世界坐标，不包括模型、倾斜摄影表面。其中ray=viewer.camera.getPickRay(movement.position)。

```javascript
var viewer = new Cesium.Viewer('cesiumContainer');
var handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
handler.setInputAction(function (movement) {
     var ray=viewer.camera.getPickRay(movement.position);
     var position = viewer.scene.globe.pick(ray, viewer.scene);
     console.log(position);
}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
```

3.获取倾斜摄影或模型点击处的坐标：场景坐标

通过viewer.scene.pickPosition(movement.position)获取，根据窗口坐标，从场景的深度缓冲区中拾取相应的位置，返回笛卡尔坐标。

```javascript
var viewer = new Cesium.Viewer('cesiumContainer');
var handler = new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
handler.setInputAction(function (movement) {
     var position = viewer.scene.pickPosition(movement.position);
     console.log(position);
}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
```

4.获取点击处屏幕坐标 ：屏幕坐标（鼠标点击位置距离canvas左上角的像素值）

```javascript
var viewer = new Cesium.Viewer('cesiumContainer');
var handler= new Cesium.ScreenSpaceEventHandler(viewer.scene.canvas);
handler.setInputAction(function (movement) {
     console.log(movement.position);
}, Cesium.ScreenSpaceEventType.LEFT_CLICK);
```

第一步 防火墙设置

一、Cesium影像图层的体系结构

一、Cesium4种获取鼠标点击位置

第一步防火墙设置