Unity性能调优手册10C#优化：GC，对象池，for/foreach，string，LINQ开发者社区

link之家

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

Unity性能调优手册10C#优化：GC，对象池，for/foreach，string，LINQ

private void Update()
    const int listCapacity = 100;
    // GC.Alloc in new of List<int>.
    var list = new List<int>(listCapacity);
    for (var index = 0; index < listCapacity; index++)
        // Pack index into list, though it doesn't make any sense in particular
        list.Add(index);
    // Randomly take a value from the list
    var random = UnityEngine.Random.Range(0, listCapacity);
    var randomValue = list[random];
    // ... Do something with the random value ...
}

private static readonly int listCapacity = 100;
// Generate a List in advance
private readonly List<int> _list = new List<int>(listCapacity);
private void Update()
    _list.Clear();
    for (var index = 0; index < listCapacity; index++)
        // Pack indexes into the list, though it doesn't make sense to do so
        _list.Add(index);
    // Randomly take a value from the list
    var random = UnityEngine.Random.Range(0, listCapacity);
    var randomValue = _list[random];
    // ... Do something with the random values ...
}

// Member Variables
private int _memberCount = 0;
// static variables
private static int _staticCount = 0;
// member method
private void IncrementMemberCount()
    _memberCount++;
// static method
private static void IncrementStaticCount()
    _staticCount++;
// Member method that only invokes the received Action
private void InvokeActionMethod(System.Action action)
    action.Invoke();
}

// When a member variable is referenced, Delegate Allocation occurs
InvokeActionMethod(() => { _memberCount++; });
// When a local variable is referenced, Closure Allocation occurs
int count = 0;
// The same Delegate Allocation as above also occurs
InvokeActionMethod(() => { count++; });

// When a static variable is referenced, GC Alloc does not occur and
InvokeActionMethod(() => { _staticCount++; });

// When a member method is referenced, Delegate Allocation occurs.
InvokeActionMethod(() => { IncrementMemberCount(); });
// If a member method is directly specified, Delegate Allocation occurs.
InvokeActionMethod(IncrementMemberCount);
// When a static method is directly specified, Delegate Allocation occurs
InvokeActionMethod(IncrementStaticCount);

// Non Alloc when a static method is referenced in a lambda expression
InvokeActionMethod(() => { IncrementStaticCount(); });

public readonly struct GenericStruct<T> : IEquatable<T>
    private readonly T _value;
    public GenericStruct(T value)
        _value = value;
    public bool Equals(T other)
        var result = _value.Equals(other);
        return result;
```csharp
在这种情况下，程序员实现了GenericStruct的IEquatable<T>接口，但忘记了对T施加限制。因此，可以为T指定不实现IEquatable<T>接口的类型，并且存在通过隐式强制转换到Object类型来使用下面的Equals的情况。
```csharp
 public virtual bool Equals(object obj);

public readonly struct GenericOnlyStruct<T> : IEquatable<T>
where T : IEquatable<T>
    private readonly T _value;
    public GenericOnlyStruct(T value)
        _value = value;
    public bool Equals(T other)
        var result = _value.Equals(other);
        return result;
}

var list = new List<int>(128);
foreach (var val in list)
}

List<int>.Enumerator enumerator = new List<int>(128).GetEnumerator();
    while (enumerator.MoveNext())
        int current = enumerator.Current;
finally
    ((IDisposable)enumerator).Dispose();
}

var list = new List<int>(128);
for (var i = 0; i < list.Count; i++)
    var val = list[i];
}

List<int> list = new List<int>(128);
int num = 0;
while (num < list.Count)
    int num2 = list[num];
    num++;
}

var count = list.Count;
for (var i = 0; i < count; i++)
    var val = list[i];
}

List<int> list = new List<int>(128);
int count = list.Count;
int num = 0;
while (num < count)
    int num2 = list[num];
    num++;
}

var array = new int[128];
foreach (var val in array)
}

int[] array = new int[128];
int num = 0;
while (num < array.Length)
    int num2 = array[num];
    num++;
}

private string CreatePath()
    var path = "root";
    path += "/";
    path += "Hoge";
    path += "/";
    path += "Fuga";
    return path;
}

private readonly StringBuilder _stringBuilder = new StringBuilder(16);
private string CreatePathFromStringBuilder()
    _stringBuilder.Clear();
    _stringBuilder.Append("root");
    _stringBuilder.Append("/");
    _stringBuilder.Append("Hoge");
    _stringBuilder.Append("/");
    _stringBuilder.Append("Fuga");
    return _stringBuilder.ToString();
}

var oneToTen = Enumerable.Range(1, 11).ToArray();
var query = oneToTen.Where(i => i % 2 == 0).Select(i => i * i);

private int[] array;
private List<int> list;
private IEnumerable<int> ienumerable;
public void GlobalSetup()
    array = Enumerable.Range(0, 1000).ToArray();
    list = Enumerable.Range(0, 1000).ToList();
    ienumerable = Enumerable.Range(0, 1000);
public void RunAsArray()
    var query = array.Where(i => i % 2 == 0);
    foreach (var i in query){}
public void RunAsList()
    var query = list.Where(i => i % 2 == 0);
    foreach (var i in query){}
public void RunAsIEnumerable()
    var query = ienumerable.Where(i => i % 2 == 0);
    foreach (var i in query){}
}

private static void LazyExpression()
    var array = Enumerable.Range(0, 5).ToArray();
    var sw = Stopwatch.StartNew();
    var query = array.Where(i => i % 2 == 0).Select(HeavyProcess).ToArray();
    Console.WriteLine($"Query: {sw.ElapsedMilliseconds}");
    foreach (var i in query)
        Console.WriteLine($"diff: {sw.ElapsedMilliseconds}");
private static int HeavyProcess(int x)
    Thread.Sleep(1000);
    return x;
}

private int[] array;
public void GlobalSetup()
    array = Enumerable.Range(0, 100_000_000).ToArray();
public void Pure()
    foreach (var i in array)
        if (i % 2 == 0)
            var _ = i * i;
public void UseLinq()
    var query = array.Where(i => i % 2 == 0).Select(i => i * i);
    foreach (var i in query)
}

using System;
using System.Threading.Tasks;
namespace A {
    public class B {
    public async Task HogeAsync(int i) {
            if (i == 0) {
                Console.WriteLine("i is 0");
                return;
            await Task.Delay(TimeSpan.FromSeconds(1));
        public void Main() {
            int i = int.Parse(Console.ReadLine());
            Task.Run(() => HogeAsync(i));
}

using System;
using System.Threading.Tasks;
namespace A {
    public class B {
        public async Task HogeAsync(int i) {
                await Task.Delay(TimeSpan.FromSeconds(1));
            public void Main() {
                int i = int.Parse(Console.ReadLine());
                if (i == 0) {
                    Console.WriteLine("i is 0");
                else {
                    Task.Run(() => HogeAsync(i));
}

// stackalloc is limited to unsafe
unsafe
    // Allocating an array of ints on the stack
    byte* buffer = stackalloc byte[BufferSize];
}

Span<byte> buffer = stackalloc byte[BufferSize];

unsafe void Hoge()
    for (int i = 0; i < 10000; i++)
        // Arrays are accumulated for the number of loops
        byte* buffer = stackalloc byte[10000];
}

struct VirtActionInvoker0
    typedef void (*Action)(void*, const RuntimeMethod*);
    static inline void Invoke (
    Il2CppMethodSlot slot, RuntimeObject* obj)
    const VirtualInvokeData& invokeData =
    il2cpp_codegen_get_virtual_invoke_data(slot, obj);
    ((Action)invokeData.methodPtr)(obj, invokeData.method);
};

public abstract class Animal
    public abstract string Speak();
public class Cow : Animal
    public override string Speak() {
        return "Moo";
var cow = new Cow();
// Calling the Speak method
Debug.LogFormat("The cow says '{0}'", cow.Speak());

// var cow = new Cow();
Cow_t1312235562 * L_14 =
(Cow_t1312235562 *)il2cpp_codegen_object_new(
Cow_t1312235562_il2cpp_TypeInfo_var);
Cow__ctor_m2285919473(L_14, /* hidden argument*/NULL);
V_4 = L_14;
Cow_t1312235562 * L_16 = V_4;
// cow.Speak()
String_t* L_17 = VirtFuncInvoker0< String_t* >::Invoke(
4 /* String AssemblyCSharp.Cow::Speak() */, L_16);

public sealed class Cow : Animal
    public override string Speak() {
        return "Moo";
var cow = new Cow();
// Calling the Speak method
Debug.LogFormat("The cow says '{0}'", cow.Speak());

// var cow = new Cow();
Cow_t1312235562 * L_14 =
(Cow_t1312235562 *)il2cpp_codegen_object_new(
Cow_t1312235562_il2cpp_TypeInfo_var);
Cow__ctor_m2285919473(L_14, /* hidden argument*/NULL);
V_4 = L_14;
Cow_t1312235562 * L_16 = V_4;
// cow.Speak()
String_t* L_17 = Cow_Speak_m1607867742(L_16, /* hidden argument*/NULL);

int F(int a, int b, int c)
    var d = Add(a, b);
    var e = Add(b, c);
    var f = Add(d, e);
    return f;
int Add(int a, int b) => a + b;

int F(int a, int b, int c)
    var d = a + b;
    var e = b + c;
    var f = d + e;
    return f;
}

Unity性能调优手册10C#优化：GC，对象池，for/foreach，string，LINQ

Unity性能调优手册10C#优化：GC，对象池，for/foreach，string，LINQ

C#Script

GC.Alloc如何产生和如何处理

New引用类型

Lambda表达式

使用泛型避免装箱的情况

关于for/foreach

对象池

string

LINQ和延迟评估

如何避免async/await开销

使用stackalloc进行优化

在IL2CPP使用seal方法调用

通过inlining内联进行优化