当前位置：首页 > news >正文

【unity c#】深入理解string，以及不同方式构造类与反射的性能测试（基于BenchmarkDotNet）

news 2025/11/19 11:24:53

出这篇文章的主要一个原因就是ai回答的性能差异和实际测试完全不同，比如说是先获取构造函数再构造比Activator.CreateInstance(type)快，实际却相反
对测试结果的评价基于5.0，因为找不到unity6确切使用的net版本，根据c#9推测是net5.0

起因：看到animancer对string的描述，我开始纠结起来要不要使用，于是有此文章
省流版就是
因为字符串常量池，字面量和方法参数都是直接比较引用，而且无论"string"+"string"还是两个相同长度不同内容的字符串都是比较的引用，如果引用不同，会比较长度，只有在使用变量存字符串，并且运行时动态修改，导致引用不同

只要不使用变量存字符串，并且运行时动态修改，就可以放心用string
反射用委托
构造用表达式树或者Activator.CreateInstance（反正不会经常调用）
拼接字符串用StringBuilder
~~有时间纠结性能不如多做两个玩法~~
~~stringbuilder和字符串常量池都是学java时的遗产，但学c#好像没被提到过，所以在这里提一嘴~~
StringReference 本质是 通过字典缓存和引用比较，也就是说，如果通过动态字符串获取缓存，仍然会在取值时执行一次字符比较判断键是否相等。如果BenchmarkDotNet是可信的，那么StringReference可能并没有起到提高效率的效果。反而因为隐式转换额外多消耗了一点

补充：

所以最终我决定放弃包装string，如果有需要扩展的就直接用【扩展方法】就好了
~~不过通过隐式类型转换+字典的缓存方式也让人大开眼界，留个印象说不定哪天用得上~~

BenchmarkDotNet可参：https://blog.csdn.net/x740073529/article/details/119934597
安装可参：https://www.cnblogs.com/WilsonPan/p/12904664.html
视频可参：https://www.bilibili.com/video/BV1DM411T7rb
简单来说就是安装包，在main入口执行，记得将运行设置为运行模式而不是调试模式：
在这里插入图片描述

为了8和5兼容需要删除自动生成全局using的设置：ImplicitUsings。右键，编辑项目文件可以找到

<PropertyGroup><OutputType>Exe</OutputType><TargetFrameworks>net8.0;net5.0</TargetFrameworks><Nullable>enable</Nullable>
</PropertyGroup>

String

主要还是参考作用，真正真实的结果只能到unity实际测试了

结论

前置知识：直接用字面量（= ‘abc’）是得到字符串常量池中的引用，所以相同字面量的字符串引用地址相等。而new或者拼接动态字符串才会开辟新的内存空间
常量形式的string，哪怕是"string"+"string"的形式，也是被字符串常量池优化过的，相当于直接比较引用
字符串的等号应该是被重写的，调用equals，并且优先比较引用，也就时候说，只有在使用变量存字符串，并且运行时动态修改，并且长度不同，才会低效

查找字符串为键的字典：取hash比较，快
查找字符串为键的字典，取值时动态拼接字符串：多出的时间消耗约等于变量拼接常量再比较，意味着除了hash计算还有一次字符比较的操作
查找值类型为键的字典：遥遥领先
引用类型作为键：比字符串稍快
包装字符串为类的效果：比引用类型稍慢
动态拼接字符串来查找：不缓存则较慢
常量字符串比较：比引用比较更快，可能有优化吧
不同常量不同长度字符串比较：稍慢，应该是判断了字符串长度
拼接常量字符串：和常量比较一样，看来是自动优化了
变量拼接常量再比较（normal3）：很慢。这里应该是比较的字符
不同常量比较：快

这里是总览，命名不规范，建议和代码对照看
在这里插入图片描述

源码

在 .NET 5 之前，很多基础类型（例如 string）的实现是在 C++ 编写的
所以只能看net8的来参考了

 public override bool Equals([NotNullWhen(true)] object? obj){if (ReferenceEquals(this, obj))return true;if (!(obj is string str))return false;if (this.Length != str.Length)return false;return EqualsHelper(this, str);}private static bool EqualsHelper(string strA, string strB)
{Debug.Assert(strA != null);Debug.Assert(strB != null);Debug.Assert(strA.Length == strB.Length);return SpanHelpers.SequenceEqual(ref Unsafe.As<char, byte>(ref strA.GetRawStringData()),ref Unsafe.As<char, byte>(ref strB.GetRawStringData()),((uint)strA.Length) * sizeof(char));
}

补充

不同常量相同长度字符串：引用级
每个字符比较：比动态拼接快。推测是少了一系列引用比较的缘故
比较常量的hash：不如每个字符比较一遍
Equals比较不同常量：比引用慢，比hash快，比较的是字符？
Equals比较相同常量：五代比等号慢，说明等号有特殊处理

可以看到5代的Equals被8代薄纱，可能是把等号的判断移到Equals了

看其他博客说动态拼接的比较方式为比较两个字符串的第一个字符：相等则比较第二个，实际测试并不是，比较字符串时改变差异字符的位置没有影响性能，估计是

[Benchmark]
public void xiangdengNormal7()
{for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf" == "asdasdfasdfasdfsafasdp";}
}
[Benchmark]
public void xiangdengNormal8()
{string a = "asdasdfasdfasdfsafasdf";string b = "asdasdfasdfasdfsafasdf";for (int i = 0; i < N; i++){for (int j = 0; j < a.Length; j++){var t = a[j] == b[j];}}
}
[Benchmark]
public void xiangdengNormal9()
{ for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf".GetHashCode() == "asdasdfasdfasdfsafasdp".GetHashCode();}
}
[Benchmark]
public void xiangdengNormal10()
{for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf".Equals("asdasdfasdfasdfsafasdp");}
}
[Benchmark]
public void xiangdengNormal12()
{for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf".Equals("asdasdfasdfasdfsafasdf");}
}

不用循环

这里是没用循环的结果，缓存每用上导致结果不准确，所以用hash的结果偏慢。但也反映出hash和string常量引用不同，反而丢失了常量池的优化
可以看到net8 比较动态字符串也快了三四倍
其他：模板字符串消耗更高

测试getHashCode的消耗

可以看出来字典查找的损耗就是源自于此，而且每次都是重新获取hash

[Benchmark]
public void getHash1()
{"asdasdfasdfasdfsafasdf".GetHashCode();
}
[Benchmark]
public void getHash2()
{stringHash.GetHashCode();
}

在这里插入图片描述

测试代码

[SimpleJob(BenchmarkDotNet.Jobs.RuntimeMoniker.Net50)]   // 在Net5.0测试(unity6 => c#9 推测=> net5.0)
[SimpleJob(BenchmarkDotNet.Jobs.RuntimeMoniker.Net80)]
public class StringTest
{// 测试数据量private const int N = 100;// 测试用的字符串和 StringHash 字典private Dictionary<string, string> stringDict;private Dictionary<int, int> intDict;private Dictionary<YourClass, int> objDict;private YourClass obj = new YourClass();private Dictionary<StringHash, StringHash> stringHashDict;private StringHash stringHash = "asdasdfasdfasdfsafasdf";// 引用应该是相同的  用字典缓存了的private StringHash stringHash2 = "asdasdfasdfasdfsafasdf";private string key = "Value";// 初始化测试数据[GlobalSetup]public void Setup(){key += "10";stringDict = new Dictionary<string, string>(N);stringHashDict = new Dictionary<StringHash, StringHash>(N);intDict = new Dictionary<int, int>(N);objDict = new Dictionary<YourClass, int>(N);// 插入数据objDict.Add(obj, 1); // 对象字典for (int i = 0; i < N; i++){string value = $"Value{i}";stringDict.Add(value, value); // 字符串字典stringHashDict.Add(value, value); // StringHash 字典intDict.Add(i, i); // 整数字典}}// 字符串字典插入性能//[Benchmark]//public void StringDictInsertion()//{//    for (int i = 0; i < N; i++)//    {//        string value = $"Value{i}";//        stringDict[value] = value;//    }//} StringHash 字典插入性能//[Benchmark]//public void StringHashDictInsertion()//{//    for (int i = 0; i < N; i++)//    {//        //string value = $"Value{i}";//        stringHashDict[new StringHash(value)] = new StringHash(value);//    }//}// 字符串字典查找性能[Benchmark]public void StringDictLookup(){for (int i = 0; i < N; i++){string value = "Value" + i;stringDict.TryGetValue(value, out _);}}[Benchmark]public void StringDictLookup2(){for (int i = 0; i < N; i++){string value = "Value10";stringDict.TryGetValue(value, out _);}}[Benchmark]public void IntDictLookup(){for (int i = 0; i < N; i++){intDict.TryGetValue(10, out _);}}[Benchmark]public void ObjDictLookup(){for (int i = 0; i < N; i++){objDict.TryGetValue(obj, out _);}} 动态字符串字典查找性能[Benchmark]public void StringDictLookupByDynamic(){for (int i = 0; i < N; i++){string value = "Value";stringDict.TryGetValue(value + "10", out _);}}[Benchmark]public void StringDictLookupByDynamic2(){for (int i = 0; i < N; i++){ stringDict.TryGetValue(key, out _);}}// StringHash 字典查找性能[Benchmark]public void StringHashDictLookup(){for (int i = 0; i < N; i++){//string value = $"Value{i}";stringHashDict.TryGetValue(new StringHash("Value10"), out _);}}[Benchmark]public void StringHashDictLookup2(){for (int i = 0; i < N; i++){//这里是缓存的stringHashDict.TryGetValue("Value10", out _);}}[Benchmark]public void xiangdengNormal(){for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf" == "asdasdfasdfasdfsafasdf";}}[Benchmark]public void xiangdengNormal2(){for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf" == "asdasdfasdfasdf" + "safasdf";}}[Benchmark]public void xiangdengNormal3(){for (int i = 0; i < N; i++){string a = "asdasdfasdfasdf";var t = "asdasdfasdfasdfsafasdf" == a + "safasdf";}}[Benchmark]public void xiangdengNormal4(){for (int i = 0; i < N; i++){var t = "asdasdfasdfasdfsafasdf" == "asdasdfasdfasdfsafasdfasfaa";}}[Benchmark]public void xiangdengNormal5(){for (int i = 0; i < N; i++){string a = "asdasdfasdfasdfsafasdf";string b = "asdasdfasdfasdfsafasdfasfaa";var t = a == b;}}[Benchmark]public void xiangdengHash(){for (int i = 0; i < N; i++){var t = stringHash == "asdasdfasdfasdfsafasdf";}}[Benchmark]public void xiangdengHash2(){for (int i = 0; i < N; i++){var t = stringHash == "asdasdfasdfasdfsafasdfasfaa";}}[Benchmark]public void xiangdengRefrence(){var t = stringHash == stringHash2;}[Benchmark]public void xiangdengInt(){var t = 123 == 123;}
}[Serializable]
public class StringHash : IComparable<StringHash>
{// 字段 private readonly string name;public int hash;private static readonly Dictionary<string, StringHash> StringHashDic = new(256);/// <summary>/// 获取或添加/// </summary>/// <param name="value"></param>/// <returns></returns>public static StringHash Get(string value){if (value is null) return null;if (!StringHashDic.TryGetValue(value, out var reference))StringHashDic.Add(value, reference = new(value));return reference;}// 构造函数public StringHash(string name){this.name = name;hash = HashCode.Combine(name);// 对于相同字符串，生成相同hash码// hash =  Animator.StringToHash(name);}// 重写隐式转换// 在 string 类型和自定义的 StateHashName 类型之间进行自动转换  就可以直接=[MethodImpl(MethodImplOptions.AggressiveInlining)]public static implicit operator StringHash(string value) => Get(value);public static implicit operator string(StringHash value) => value?.name;// 覆盖 ToString 方法// 特性：尽可能将方法内联化   比委托调用快十倍[MethodImpl(MethodImplOptions.AggressiveInlining)]public override string ToString() => name;// 重载 == 运算符public static bool operator ==(StringHash left, StringHash right){if (ReferenceEquals(left, null))return ReferenceEquals(right, null);return left.Equals(right);}// 重载 != 运算符public static bool operator !=(StringHash left, StringHash right){return !(left == right);}// 重写 Equals 和 GetHashCode 方法  //public override bool Equals(object obj)//{//    if (ReferenceEquals(this, obj)) return true;//    if (obj is StringHash other)//    {//        // 检查哈希值//        if (hash != other.hash)//            return false;//        return true;//        // 哈希值相等时，进一步比较字符串内容 处理hash碰撞//        //return name == other.name;// == 对于 null 会非常安全，但 Equals 可能会抛出异常//    }//    return false;//}// 会被字典调用// 如果键冲突，会调用Equals public override int GetHashCode(){return hash;}// 比较方法public int CompareTo(StringHash other) => name.CompareTo(other?.name);
}

构造类测试

反射经常能简化代码，但也有性能损耗，索性可以避免，委托只是其中一种方式。

带缓存表达式树调用构造函数（委托） : 只比正常慢了一点
表达式树（委托）
正常构造
通过反射获取构造方法再调用：慢了十倍以上
反射+强制类型转换：慢了5倍的样子
反射+as 类型转换：as确实比强转慢一点，但不多
泛型反射：和反射一样
结果： net8.0对反射似乎有不小的优化，可惜unity版本更不上

测试代码

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System.Linq.Expressions;
using System;  [MemoryDiagnoser]
[SimpleJob(BenchmarkDotNet.Jobs.RuntimeMoniker.Net50)]   // 在Net5.0测试(unity6 => c#9 推测=> net5.0)
[SimpleJob(BenchmarkDotNet.Jobs.RuntimeMoniker.Net80)]
public class TestClass
{private Action _delegate;private event Action _event;int iterations = 10000;static void Main(string[] args)//main函数{// 运行 BenchmarkTest 里标记为 Benchmark 的方法，比较它们的性能var summary = BenchmarkRunner.Run<TestClass>();Console.WriteLine(summary);} private Func<YourClass> constructorDelegate;[GlobalSetup]public void Setup(){var type = typeof(YourClass);// 获取无参数的构造函数var constructor = type.GetConstructor(Type.EmptyTypes);// 创建一个表达式树，表示调用构造函数的操作var newExpression = Expression.New(constructor);// 创建一个 Lambda 表达式，指定返回类型为 YourClassvar lambda = Expression.Lambda<Func<YourClass>>(newExpression);// 编译表达式树，得到一个委托constructorDelegate = lambda.Compile();}[Benchmark]public void biaodashiHuancun(){YourClass obj = constructorDelegate();}[Benchmark]public void biaodashi(){var type = typeof(YourClass);// 获取无参数的构造函数var constructor = type.GetConstructor(Type.EmptyTypes);// 创建一个表达式树，表示调用构造函数的操作var newExpression = Expression.New(constructor);// 创建一个 Lambda 表达式，指定返回类型为 YourClassvar lambda = Expression.Lambda<Func<YourClass>>(newExpression);// 编译表达式树，得到一个委托var constructorDelegate = lambda.Compile();YourClass obj = constructorDelegate();} [Benchmark]public void Normal(){YourClass obj = new YourClass();}[Benchmark]public void gouzao(){var type = typeof(YourClass);var constructor = type.GetConstructor(Type.EmptyTypes); YourClass obj = constructor.Invoke(null) as YourClass;}[Benchmark]public void fanshe(){var type = typeof(YourClass); // 请替换为你的类 YourClass? obj = (YourClass)Activator.CreateInstance(type);}[Benchmark]public void fansheAs(){var type = typeof(YourClass); // 请替换为你的类 YourClass? obj = Activator.CreateInstance(type) as YourClass;}[Benchmark]public void fansheFanxing(){var type = typeof(YourClass);YourClass? obj = Activator.CreateInstance<YourClass>();}}//省略了字段
public class YourClass
{ public YourClass(){ }
}

额外测试

空类测试

类的属性是否影响构造消耗：是
as的消耗具体多大：可以忽略，甚至更快了

十几个字段的类

as转换为接口和as转换为类消耗差距：差不多
as和is消耗：差不多

代码：

[Benchmark]
public void fanshe()
{var type = typeof(YourClass); // 请替换为你的类 object obj = Activator.CreateInstance(type);
}
[Benchmark]
public void fansheAs()
{var type = typeof(YourClass); // 请替换为你的类 YourClass? obj = Activator.CreateInstance(type) as YourClass;
}
[Benchmark]
public void fansheAsInterface()
{var type = typeof(YourClass); // 请替换为你的类 IYourInterface? obj = Activator.CreateInstance(type) as IYourInterface;
}
[Benchmark]
public void TestIS()
{var type = typeof(YourClass); // 请替换为你的类 _ = Activator.CreateInstance(type) is IYourInterface;
}

反射测试

参考：https://blog.walterlv.com/post/create-delegate-to-improve-reflection-performance.html

直接调用
通过方法（委托）调用：慢了十倍（可能是有额外的检查）
通过委托调用：和通过方法差不多
通过缓存的反射方法：慢了百倍
通过反射：慢了两百倍

代码

public class Fanshe
{private StubClass instance;private MethodInfo method;private Func<int, int> pureFunc;private Func<int, int> func;// 初始化测试数据[GlobalSetup]public void Setup(){instance = new StubClass();method = typeof(StubClass).GetMethod(nameof(StubClass.Test), new[] { typeof(int) });pureFunc = value => value;// 使用反射创建一个委托func = InstanceMethodBuilder<int, int>.CreateInstanceMethod(instance, method);}// 直接调用[Benchmark]public void DirectCall(){var result = instance.Test(5);}// 使用 Func 委托调用[Benchmark]public void FuncCall(){var result = pureFunc(5);}// 使用反射创建的委托调用[Benchmark]public void DelegateFromReflection(){var result = func(5);}// 使用缓存的反射方法调用[Benchmark]public void CachedReflectionCall(){var result = method.Invoke(instance, new object[] { 5 });}// 使用每次都反射查找的方法调用[Benchmark]public void DirectReflectionCall(){var result = typeof(StubClass).GetMethod(nameof(StubClass.Test), new[] { typeof(int) })?.Invoke(instance, new object[] { 5 });}
}