C# 我是否使用了错误的'；stackalloc'；处理Unity中要使用的string.Split（）函数？

我使用统一。但是这个引擎不能使用Span。。 所以，我做了字符串解析函数

我的函数用途是将字符串转换为单个结构值（int、float、bool、UnityEngine.Vector4等） 我考虑了如何尽可能不生成GC

从xml文件中读取字符串数据 字符串数据规范的示例有：“-1234.23234，-.232.344”，“554”，“-.55”

在测试中，我发现了一些有趣的东西

    public unsafe Vector4 GetVectorToStackAlloc()
    {
        Vector4 vec = Vector4.Zero;

        char* data = stackalloc char[8];
        int dot = -1;
        int index = 0;
        int colume = 0;
        for (int i = 0; i < Str.Length; ++i)
        {
            if (Str[i] == Token)
            {
                Parse();

                dot = -1;
                index = 0;
                colume++;
            }
            else
            {
                if (Str[i] == '.') dot = index;
                data[index++] = Str[i];
            }
        }

        Parse();

        void Parse()
        {
            if (index == 0) return;

            bool isMinus = data[0] == '-';
            int length = isMinus ? 1 : 0;
            int mul = dot != -1 ? (dot - index) + 1 : 0;

            for (int x = index - 1; x >= length; --x)
            {
                if (data[x] == '.') continue;

                int k = data[x] - '0';
                float m = MathF.Pow(10, mul++);
                vec[colume] += k * m;
            }

            if (isMinus) vec[colume] *= -1;
        }

        return vec;
    }

    public Vector4 GetDefaultVector()
    {
        Vector4 vec = Vector4.Zero;

        string[] split = Str.Split(Token);
        for (int i = 0; i < split.Length; ++i)
        {
            if (string.IsNullOrWhiteSpace(split[i])) continue;
            vec[i] = float.Parse(split[i]);
        }

        return vec;
    }

    public Vector4 GetSpanVector()
    {
        Vector4 vec = Vector4.Zero;

        Span<char> span = stackalloc char[8];
        int index = 0;
        int colume = 0;
        for (int i = 0; i < Str.Length; ++i)
        {
            if (Str[i] == ',')
            {
                if (index == 0) { vec[colume++] = 0; }
                else vec[colume++] = float.Parse(span);

                index = 0;
                span.Clear();
            }
            else span[index++] = Str[i];
        }

        vec[colume] = float.Parse(span);
        return vec;
    }

公共不安全向量4 GetVectorToStackAlloc（）
{
vector4vec=Vector4.0；
char*data=stackalloc char[8]；
int点=-1；
int指数=0；
整列=0；
对于（int i=0；i=长度；--x）
{
如果（数据[x]='.'）继续；
int k=数据[x]-“0”；
float m=MathF.Pow（10，mul++）；
vec[colume]+=k*m；
}
if（isMinus）vec[colume]*=-1；
}
返回向量；
}
公共向量4 GetDefaultVector（）
{
vector4vec=Vector4.0；
string[]split=Str.split（标记）；
对于（int i=0；i

在测试过程中，我发现float.Parse（）函数中存在开销，并使用单个float进行了测试

public unsafe float GetStackAllocFloat()
    {
        float value = 0;
        char* data = stackalloc char[8];

        int dot = -1;
        int index = 0;
        for (int i = 0; i < Str.Length; ++i)
        {
            if (Str[i] == '.') dot = index;
            data[index++] = Str[i];
        }

        if (index == 0) return value;

        bool isMinus = data[0] == '-';
        int length = isMinus ? 1 : 0;
        int mul = dot != -1 ? (dot - index) + 1 : 0;

        for (int x = index - 1; x >= length; --x)
        {
            if (data[x] == '.') continue;

            int k = data[x] - '0';
            float m = MathF.Pow(10, mul++);
            value += k * m;
        }

        if (isMinus) value *= -1;
        return value;
    }

    public unsafe float GetDefaultFloat()
    {
        return float.Parse(Str);
    }

public不安全float GetStackAllocFloat（）
{
浮点数=0；
char*data=stackalloc char[8]；
int点=-1；
int指数=0；
对于（int i=0；i=长度；--x）
{
如果（数据[x]='.'）继续；
int k=数据[x]-“0”；
float m=MathF.Pow（10，mul++）；
值+=k*m；
}
如果（isMinus）值*=-1；
返回值；
}
公共不安全浮点GetDefaultFloat（）
{
返回float.Parse（Str）；
}

我认为如果测试方法正常，最好使用

stackalloc

。

---

是我弄错了吗？

好的，我再次测试了它，以尽可能地安装Unity引擎

我觉得还不错

public readonly string[]Strs=新字符串[200]{//数据已填充..}
公共常量字符标记='，'；
[基准]
公共不安全向量4 GetVectorToStackAlloc（）
{
Vector4结果=Vector4.0；
int r=标准长度-1；
而（r！=-1）
{
vector4vec=Vector4.0；
char*data=stackalloc char[12]；
int点=-1；
int指数=0；
整列=0；
字符串Str=Strs[r--]；
对于（int i=0；i=length；--x）
{
如果（_data[x]='.'）继续；
int k=_数据[x]-“0”；
float m=MathF.Pow（10，mul++）；
val=k*m；
}
返回isMinus？val*-1:val；
}
}
[基准]
公共向量4 GetDefaultVector（）
{
Vector4结果=Vector4.0；
int r=标准长度-1；
而（r！=-1）
{
vector4vec=Vector4.0；
字符串Str=Strs[r--]；
string[]split=Str.split（标记）；
对于（int i=0；i

它不是

float.Parse

th

public readonly string[] Strs = new string[200] { // data is fill .. }
public const char Token = ',';

    [Benchmark]
    public unsafe Vector4 GetVectorToStackAlloc()
    {
        Vector4 result = Vector4.Zero;

        int r = Strs.Length - 1;
        while (r != -1)
        {
            Vector4 vec = Vector4.Zero;

            char* data = stackalloc char[12];
            int dot = -1;
            int index = 0;
            int colume = 0;

            string Str = Strs[r--];
            for (int i = 0; i < Str.Length; ++i)
            {
                if (Str[i] == Token)
                {
                    vec[colume++] = Parse(index, data, dot);

                    dot = -1;
                    index = 0;
                }
                else
                {
                    if (Str[i] == '.') dot = index;
                    data[index++] = Str[i];
                }
            }

            vec[colume] = Parse(index, data, dot);
            result.x += vec.x;
        }
        return result;

        float Parse(int _index, char* _data, int _dot)
        {
            if (_index == 0) return 0;
            float val = 0;

            bool isMinus = _data[0] == '-';
            int length = isMinus ? 1 : 0;
            int mul = _dot != -1 ? (_dot - _index) + 1 : 0;

            for (int x = _index - 1; x >= length; --x)
            {
                if (_data[x] == '.') continue;

                int k = _data[x] - '0';
                float m = MathF.Pow(10, mul++);
                val = k * m;
            }

            return isMinus ? val * -1 : val;
        }
    }

    [Benchmark]
    public Vector4 GetDefaultVector()
    {
        Vector4 result = Vector4.Zero;

        int r = Strs.Length - 1;
        while (r != -1)
        {
            Vector4 vec = Vector4.Zero;
            string Str = Strs[r--];
            string[] split = Str.Split(Token);
            for (int i = 0; i < split.Length; ++i)
            {
                if (string.IsNullOrWhiteSpace(split[i])) continue;
                vec[i] = float.Parse(split[i]);
            }

            result.x += vec.x;
        }

        return result;
    }