分类程序下的文章 | 高级人

docker 镜像加速器

时间: 2024-12-13
分类: 程序
阅读：次

https://yeasy.gitbook.io/docker_practice/install/mirror

腾讯云的镜像加速地址亲测可用（限腾讯云内部服务器）

AlphaSSL

AlphaSSL证书是全球著名SSL证书颁发机构GlobalSign旗下的信息安全产品，是专业的SSL证书提供商，专业提供便宜SSL证书

支持的SSL证书类型较为单一

AlphaSSL证书属于入门级SSL证书，目前仅支持域名验证(DV SSL证书)，所以价格便宜，通常一年只要几百元，便可为个人网站提供最基本的安全保护。

审核简单、签发速度快

AlphaSSL证书按照网站保护域名数量不同，有单域名证书和通配符证书可供选择，申请流程很简单，CA机构只需验证域名所有权，域名验证通过后CA便会签发证书。

此外，AlphaSSL证书除了价格便宜之外，还带有兼容性强、强大的加密功能的优点。所有流行的浏览器和移动设备都可以识别AlphaSSL证书。AlphaSSL证书是从2048位的GlobalSign根证书颁发的，该证书是世界上运营时间最长，最受信任的权威之一，同时还将在客户和网站之间获得256位加密强度，这是当今使用率最高的加密强度。

通过上文介绍，目前AlphaSSL证书仅有DV SSL证书可选，如果是企业网站的话，还是选GlobalSign旗下品牌的安全级别高的企业型OV SSL证书或增强型EV SSL证书，以加强网站信息安全保护。

购买一个Token

申请流程参考

谈一谈Unity 的 Scriptable Build Pipeline

时间: 2024-04-25
分类: 程序
阅读：次

Unity的Scriptable Build Pipeline (SBP) 提供了一种更灵活的构建方式，以package 的形式提供，将一些常用的构建类和接口从C++层移动到了C#层。，与传统的构建接口不同，SBP在构建时并不会生成manifest,而是会在library下生成缓存，实际首次构建时长会比buildpipeline慢一些，但如果再次调用构建接口，就会使用缓存来增量构建，减少构建时长。除此之外，SBP在构建完成后会在AB包目录输出构建步骤的耗时的详细信息和耗时日志，可以用Trace Event Profiling Tool打开，方便profiler不同的构建步骤。Unity的Scriptable Build Pipeline (SBP) 提供了一种更灵活的构建方式，以package 的形式提供，将一些常用的构建类和接口从C++层移动到了C#层。，与传统的构建接口不同，SBP在构建时并不会生成manifest,而是会在library下生成缓存，实际首次构建时长会比buildpipeline慢一些，但如果再次调用构建接口，就会使用缓存来增量构建，减少构建时长。除此之外，SBP在构建完成后会在AB包目录输出构建步骤的耗时的详细信息和耗时日志，可以用Trace Event Profiling Tool打开，方便profiler不同的构建步骤。

以下是个人总结的一些SBP的优点与缺点。

优点：

良好的设计接口,能更灵活的控制构建过程，例如深度定制AB包构建内容，指定单个Ab包压缩格式、依赖查找回调等。将构建任务粒度拆分更细，例如压缩、打图集、编译脚本，文件系列化等。为构建并行化为了准备使用BuildCache，加快构建速度，不同构建机之间可以共享同一份BuildCache 构建更细粒度的步骤profiler

缺点：

Task的设计看起来很美好，但大部份任务并不支持并行化，自定义task的可行性比较低增量构建不完善，依然有bug,使用buildcache后bug会传播到其它构建线过度的设计，看似提供了更灵活的接口，实则很难正确的实现这些接口，比如看似可以通过IBundleBuildContent的BundleLayout来控制每个ab包的内容，但由于unity的依赖关系很难从上层应用通过Unity提供的接口计算正确，所以从上层来控制每个ab包的内容基本上不可能单个ab包的压缩格式通过回调来指定的做法比较不合理，这样做需要用字典来存储每个ab包压缩格式，增加了额外内存和构建时长，同时这样的代码写起来也比较麻烦。一种比较简单的做法是在AssetBundleBuild中增加一个压缩格式参数 Build Cache在Library下占用硬盘空间较大

参考链接

trace-event-profiling-tool

Unity项目优化之数据集合优化

时间: 2024-03-28
分类: 程序
阅读：次

通过详细的理解Array、List、和Dictionaries让你的游戏运行速度快十倍

这篇文章的主要目标是：过详细的理解Array、List、和Dictionaries，让你的游戏运行速度快十倍。

我应该使用Array吗？我应该使用List吗？噢，等等，或者使用Dictionaries？为什么我的循环花了那么长时间呢? ? 在我代码中看不到任何的错误，那么为什么我的代码执行那么慢？为什么查找我想要的对象话费那么长时间？我看不到任何的GC（垃圾回收器）处理，然而我的游戏为什么那么的延迟？

“这些是我们在开发一个游戏的时候经常遇到的一些常见问题。” 但正是这些常见问题最让游戏开发者苦恼了！！几毫秒的延迟就可以让游戏开发者失去理智！！最终，我们总是推卸责任喊道：“这个是Unity引擎的错误，我的代码是完美的！！” 那好吧，这并非总是如此，只是有的时候我们不正确使用数据结构中的集合造成的，且心里咒骂着：“集合是如此的慢！” 在应用程序中，我们一般通过以下两种方式去管理相邻对象组： 1．通过创建对象数组（Array） 2．通过创建对象的集合我们应该记得每一种集合的具体用法，以及它的优点和缺点，并且知道在什么情况下使用它是最佳的。

在文章中，我将列举在Unity中所有常用的数组，这样有利于你更好的理解集合。

什么是集合？

集合是特殊的类用于数据的存储和检索，集合类通常是用来为元素动态的分配内存，并且通过下标索引来访问列表里的每一个元素等等。这些类创建Object类的对象的集合,在C#中所有数据类型的基类是Object类。集合可以根据应用程序的请求动态的扩展和缩减，这就是集合的主要优势。集合使得内存管理和数据管理的过程变得相当简单。那么，在Unity中常用的集合有那几个呢？在Unity中Dictionary（字典）和 List（列表）是最常用的集合，让我给初学者对于Dictionary（字典）和 List（列表）的一些基本概念。如果知道的朋友可以跳过。

List C#List< T >类代表一个强大的List类型（其实就是泛型List类）可以通过索引访问的列表对象，它可以存储没有指定类型的对象集合。它和其他集合一样都有以下功能：添加（Add），插入（Insert），移除（Remove），查找（Search）等等。 List的索引表示方式和Array一样，然后它的主要优势是动态的指定容器的大小。例如，我们可以这样定义一个Object的List<>： List<GameObject> myListOfGameObjects = new List<GameObject>();
Dictionary Dictionary实际上使一个哈希表类型的替代品 Dictionary代表一个键值对例如，如果5代表Red，10代表Green，我们便在Dictionary中通过5键（Key）找到Red这个值（Value）。因此，我们如果想要找到Red这个值（Value），只要记住5这个键（Key）即可那么，Dictionary是怎么查找数据的呢？例如，我们可以这样定义一个Dictionary对象： //Dictionary<int, String>: //在这个例子中，“int”是键，“String”是值 Dictionary<int,String> myDictionary = new Dictionary<int, String>();

现在，这篇文章的主要目标是关于优化使用集合，而不是学习集合，因此我们将忽略集合的学习。但是，如果你想要详细的学习它，你可以下面的链接，这将会帮你更详细的学习集合的概念：

https://link.juejin.cn/?target=https%3A%2F%2Fmsdn.microsoft.com%2Fen-us%2Flibrary%2Fybcx56wz.aspx https://www.dotnetperls.com/ https://link.juejin.cn/?target=http%3A%2F%2Fwww.tutorialspoint.com%2Fcsharp%2Fcsharp_collections.htm

集合是怎么影响游戏的呢？

让我们一起看一个例子，并且理解集合石怎么影响我们的游戏的。 1.在Unity中依照下面方式来设置场景 css复制代码a) 创建一个空的游戏物体（Empty Game），并且更改名字（你随意，在这里我命名为Test）

2.创建一个脚本，并且命名为你喜欢的名字 css复制代码a) 在这里我把命名为GenericCollectionsTest.cs

b) 我使用的是C#作为我的脚本语言，你也可以使用Javascript，如果你愿意的话。

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;

public class GenericCollectionsTest : MonoBehaviour
{
    #region PUBLIC_DECLARATIONS
    public int numberOfIterations = 10000000;
    #endregion
    #region PRIVATE_DECLARATIONS
    private Stopwatch stopWatch;
    private List<int> intList;
    private Dictionary<int, int> intDictionary;
    private int[] intArray;
    #endregion
    #region UNITY_CALLBACKS

    void Start()
    {
        stopWatch = new Stopwatch();
        intArray = new int[numberOfIterations];
        intList = new List<int>();
        intDictionary = new Dictionary<int, int>();
        AddFakeValuesInArray(numberOfIterations);
        AddFakeValuesInList(numberOfIterations);
        AddFakeValuesInDictionay(numberOfIterations);
    } 

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            PerformTest();
        }

        if (Input.GetKeyDown(KeyCode.S))
        {
            SearchInList(111);
            SearchInDictionary(numberOfIterations - 1);
            UnityEngine.Debug.Log("SearchComplete");
        }
    }
    #endregion 

    #region PRIVATE_METHODS 
    private void AddFakeValuesInArray(int iterations)
    {
        for (int i = 0; i < iterations; i++)
        {
            intArray[i] = Random.Range(0, 100);
        }
    } 

    private void AddFakeValuesInList(int iterations)
    {
        for (int i = 0; i < iterations; i++)
        {
            intList.Add(Random.Range(0, 100));
        }
        intList[iterations - 1] = 111;
    } 

    private void AddFakeValuesInDictionay(int iterations)
    {
        for (int i = 0; i < iterations; i++)
        {
            intDictionary.Add(i, Random.Range(0, 100));
        }
        intDictionary[iterations - 1] = 111;
    } 

    private void SearchInList(int value)
    {
        #region FIND_IN_LIST
        stopWatch.Start();
        int index = intList.FindIndex(item => item == value);
        stopWatch.Stop();
        UnityEngine.Debug.Log("Index " + index);
        UnityEngine.Debug.Log("Time Taken to Find in List  "+stopWatch.ElapsedMilliseconds +" ms");
        stopWatch.Reset();
        #endregion

        #region CHECK_IF_CONTAINS_VALUE_IN_LIST
        stopWatch.Start();
        bool containsValue = intList.Contains(value);
        stopWatch.Stop();
        UnityEngine.Debug.Log(containsValue);
        UnityEngine.Debug.Log("Time Taken To Check in List "+stopWatch.ElapsedMilliseconds +" ms");
        stopWatch.Reset();
        #endregion
    } 

    private void SearchInDictionary(int key)
    {
        #region FIND_IN_DICTIONARY_USING_REQUIRED_KEY
        stopWatch.Start();
        int value = intDictionary[key];
        stopWatch.Stop();
        UnityEngine.Debug.Log(("Time Taken to Find in Dictionary   " + stopWatch.ElapsedMilliseconds + " ms"));
        stopWatch.Reset();
        #endregion 

        #region CHECK_IF_DICTIONARY_CONTAINS_VALUE
        stopWatch.Start();
        bool containsKey = intDictionary.ContainsKey(key);
        stopWatch.Stop();
        UnityEngine.Debug.Log(containsKey);
        UnityEngine.Debug.Log("Time taken to check if it contains key in Dictionary" + stopWatch.ElapsedMilliseconds + " ms");
        stopWatch.Reset();
        #endregion
    } 

    private void PerformTest()
    {
        #region ARRAY_ITERATION
        stopWatch.Start();
        for (int i = 0; i < intArray.Length; i++)
        {

        }
        stopWatch.Stop();
        UnityEngine.Debug.Log("Time Taken By Array "+stopWatch.ElapsedMilliseconds + "ms");
        stopWatch.Reset();
        #endregion 

        #region LIST_ITERATION
        stopWatch.Start();
        for (int i = 0; i < intList.Count; i++)
        { 

        }
        stopWatch.Stop();
        UnityEngine.Debug.Log("Time Taken By List "+stopWatch.ElapsedMilliseconds + "ms");
        stopWatch.Reset();
        #endregion

        #region LIST_ITERATION_BY_FOREACH_LOOP
        stopWatch.Start();
        foreach (var item in intList)
        { 

        }
        stopWatch.Stop();
        UnityEngine.Debug.Log("Time Taken By List Using foreach  "+stopWatch.ElapsedMilliseconds + "ms");
        stopWatch.Reset();
        #endregion 

        #region DICTIONARY_ITERATIOn_LOOP
        stopWatch.Start();
        foreach (var key in intDictionary.Keys)
        {

        }
        stopWatch.Stop();
        UnityEngine.Debug.Log("Time Taken By Dictionary "+stopWatch.ElapsedMilliseconds + "ms");
        stopWatch.Reset();
        #endregion
    }
    #endregion
}

3.分解代码和理解代码 a) 让我们来分解这个代码，并且一步一步的理解代码 b) 在这里显示了一些数据，如下表所示：

intArray

    一个int类型的数组（Array）

intList

    一个int类型的列表（List）

intDictionary

    一个键值都是int类型的字典（Dictionary）

现在，让我们来看看Start()方法

void Start()

    {

        stopWatch = new Stopwatch();

        intArray = new int[numberOfIterations];

        intList = new List<int>();

        intDictionary = new Dictionary<int, int>();

        AddFakeValuesInArray(numberOfIterations);

        AddFakeValuesInList(numberOfIterations);

        AddFakeValuesInDictionay(numberOfIterations);

    }

在这里，我初始化了数组（Array），列表（List），字典（Dictionary），并且为他们添加了一些随机值。

e) 正如你在代码中看到的，我创建了一个Private（私有的）方法为那些集合添加一些随机数。

f) 在这里我也使用了Stopwatch对象用来时间和性能测试，并且也在Start()里进行了初始化

g) 如果你还不知道Stopwatch是怎么运作的，在往后学习之前，先去了解它，这样有利于你接下来的理解。

h) 请参考以下链接： https://www.dotnetperls.com/stopwatch 现在让我们看一看PerformTest()方法

j) 我把该方法分为了4块，这样更有利于理解：

ARRAY_ITERATION

    这里我们只遍历该数组

LIST_ITERATION

    这里我们只使用简单的for循环遍历列表

LIST_ITERATION_BY_FOREACH_LOOP

    这里我们使用foreach循环遍历列表

DICTIONARY_ITERATION_LOOP

    这里我们遍历字典

k) 正如你在Update()中看到，我们在按下“Space”键（空格键）时调用PerformTest()。

l) 现在，我们将执行项目去测试一番。

为了获得性能的确切数据，我们让每一个种类型的数据集合迭代10万次。你的输出应该跟下面的图片一样：

那么，这就意味着Array（数组）是最好的吗？我们应该只使用Array（数组）就行了嘛？不，不是这样的。正如我们之前说的那样，我们要有计划的使用集合。

o) 只是我们要明确我们的需要，按自己的需求指定需用的集合类型。

P) 让我们一起去了解一些，我们应该在什么情况下使用什么样的集合类型。

情况1：在整个游戏中，对象的数量保持不变

· 在这种情况下使用List（列表）和Dictionary（字典）是不合适的，很显然对象的数量没有改变。然而使用一个集合为什么会给内存和CPU造成额外的消耗呢？ ·在这里，Array（数组）的效率是List（列表）的两倍。

情况2：在游戏中对象的数量在不断的变化

·我们从上面中了解到Array（数组）不是动态分配的，显然，我在这种情况下应该使用List（列表）。因为对象在持续的改变，所以List（列表）比Dictionary要快很多。 ·List（列表）常用来管理对象池 ·List（列表）比Dictionary（字典）快将近8倍左右 ·使用foreach循环来遍历List比使用for循环多消耗将近 3倍的时间（这个在《关于Foreach你不知道的事儿》中有详细说明）。所以这意味着我们应该完全停止使用字典吗? 不是的，让我们通过下面的例子更好的理解它。在代码中有两个方法SearchInList() 和 SearchInDictionary()。通过下面表格进行了解：

SearchInList()

    方法的第一部分是传递一个值给列表，然后在列表中去查找这个值，第二部分是判断这个列表是否存在该值，最后根据判断条件返回相应的布尔值

SeatchInDictionary()

    方法的第一部分是根据这个传入的键去找到这个键对应的值，第二部分通过使用ContainsKey()方法判断这个方法里是否有指定的键

让我们在一次运行项目进行测试，且在运行中按下“S”键后看输出日志的显示。输出将是这样的:

结论

从上图中便能得知，使用Dictionary（字典）进行搜索几乎不消耗任何时间因此，如果在整个游戏运行的时候需要不断的寻找一些对象时，明智的选择就是选择使用Dictionary（字典）。接受它吧，你的游戏不能没有集合！是的，这是正确的。我们只需要知道在什么情况下使用什么类型的集合。结论很简单,有三个基本原则: 1.当一个对象的数量保持不变时和需要频繁的查找对象时不要使用List（列表）。 2.如果是动态的对象，且不需要频繁查找对象时，使用List（列表）是最佳的选择。 3.需要快速查找，并且对象的改变很小时，使用Dictionary（字典）是最佳的选择。 4.当一个对象的数量保持不变时，使用Array（数组）是最佳的选择（自己添加的）

你真的了解C#中的Math.Round么?

时间: 2022-10-11
分类: 程序
阅读：次

开发者为了实现小数点后 2 位的四舍五入，编写了如下代码，

var num = Math.Round(12.125, 2); 代码非常的简单，开发者实际得到的结果是12.12, 这与其所预期的四舍五入结果12.13相悖。

其实产生这个结果的原因是由于Math.Round 默认使用的并非是四舍五入的原则，而是四舍六入五成双的原则。

四舍六入五成双

所谓的四舍六入五成双，就是说当确定有效位数之后，有效位数的下一位如果小于等于4就舍去，如果大于等于6就进一，当有效位数的下一位是5的时候

如果5前为奇数，就舍五进一如果5前为偶数，就舍五不进（0是偶数）从统计学上将，四舍六入五成双比四舍五入要更精确，因为大量计算的情况下，四舍五入逢五进一，会导致结果偏向大数。

例如：

1.15+1.25+1.35+1.45 = 5.2

如果有效位数是小数点后一位，使用四舍五入原则得到的结果

1.2 + 1.3 + 1.4 + 1.5 = 5.4

而使用四舍六入五成双原则得到的结果是

1.2 + 1.2 + 1.4 + 1.4 = 5.2

由此可见四舍六入五成双原则得到的结果更为精确。

Math.Round的四舍五入那么如何使用Math.Round实现预期的四舍五入呢？

其实C#中的Math.Round提供了非常多的重载方法，其中有两个重载方法是，

public static double Round (double value, int digits, MidpointRounding mode);
public static decimal Round (decimal d, int decimals, MidpointRounding mode);

这两个方法都提供了第三个参数mode, mode是一个MidpointRounding的枚举变量，它有2个可选值

AwayFromZero - 四舍五入 ToEven - 四舍六入五成双所以如果我们希望的到一个理想中四舍五入的结果，，我们可以改用如下代码：

var num = Math.Round(12.125, 2, MidpointRounding.AwayFromZero);

高级人 - AI