Question

我有一个C＃类，我需要用它来实例化数百万个对象。所以我需要让课堂重量轻，速度超快。我在其中声明了一些功能。所以我担心的是，声明所有这些函数会使类慢或消耗更多内存。我也可以选择将这些函数声明为另一个类。这是班级：

internal class Var
{
    public dynamic data;
    public int index;
    public VarTypes type;
    public bool doClone = false;
    public Var Clone(bool doClone)
    {
        var tmpVar = Clone();
        tmpVar.doClone = doClone;
        return tmpVar;
    }
    public Var Clone()
    {
        if (doClone)
            return new Var() { data = data, index = index, type = type };
        else
            return this;
    }
    public void Clone(Var old)
    {
        this.data = old.data;
        this.index = old.index;
        this.type = old.type;
    }
    public override string ToString()
    {
        if (type == VarTypes.Function)
        {
            StringBuilder builder = new StringBuilder("function ");
            if (data.Count == 4)
                builder.Append(data[3].ToString());
            builder.Append("(");
            for (int i = 1; i < data[1][1].Count; i++)
                builder.Append(data[1][1][i].ToString() + ",");
            if (builder[builder.Length - 1] == ',')
                builder.Remove(builder.Length - 1, 1);
            builder.Append(")");
            return builder.ToString();
        }
        else
            return data.ToString();
    }
}

Answer 1

由于向类中添加了更多方法，您的类实例不会消耗更多内存。一个类实例有a constant minimum size，然后它的大小只会随着你添加字段（或autoproperties，在每个autoproperty为你添加一个字段的意义上）而增加。这是因为当您实例化一个类时，您实际上是在实例化一个内存区域（大多数情况下）只包含该实例字段的值。

存在最小大小，因为每个类实例都存储enables various operations of the runtime的一些信息，例如GC。这些信息主要以指向运行时的类型范围内部结构的指针的形式存储，这意味着它们不会随着类实例的数量而扩展 - 您将获得相同的平面开销来存储类型的方法是否实例化零或一千个实例。

Answer 2

从another answer开始，如果您担心函数调用开销，请为每种方法启用积极内联：

// in mscorlib.dll so should not need to include extra references
using System.Runtime.CompilerServices; 

⋮

 [MethodImpl(MethodImplOptions.AggressiveInlining)]
 void MyMethod(...)

在类中声明太多方法会使它变大吗？

2 个答案: