C# 对温度等计量单位使用结构有什么好处？

我运行下面的代码来测试我的UOM程序中一些常见用法的速度，我感到非常惊讶。结果是：所有测试都在调试模式下运行了100万次（运行模式给出了类似的差异）。从速度的角度来看，使用计量单位的结构似乎没有什么真正的优势，所以有人能告诉我们有什么优势吗？（我有一个很大的数字运算程序，我对此非常感兴趣）。如果下面的示例代码有任何错误，也请让我知道。我真正想要的是在不使代码冗长的情况下处理UOM的最方便的方法（UOM*UOM而不是UOM.Value*UOM.Value将是最好的，但它显然不是最高效的）。所有时间都在ms

多特普利双打7分

多结构字段8

多重结构属性232

使用重载*运算符141的多重温度结构

多类字段7

倍增并将倍增加载到对象数组692中

乘以结构字段并加载到对象数组719中

乘以结构字段并将新结构加载到对象数组926中

使用重载运算符乘法结构，并将结构加载到对象数组906中

将类字段相乘并加载到对象数组697中

增加类字段并将新类加载到对象数组964中

使用重载*运算符乘法类&将类装入对象数组948

public class TestSpeed
{
    public class TempClass
    {
        public double value=100;
        private double v;

        public TempClass(double v)
        {
            this.v = v;
        }

        public static TempClass operator *(TempClass t1, TempClass t2)
        {
            return new TempClass(t1.value * t2.value);
        }
    }

    public struct TempStruct
    {
        public double value;

        public TempStruct(double v)
        {
            value = v;
        }

        public double GetTemp
        {
            get { return value; }
            set { this.value = value; }
        }

        public static TempStruct operator *(TempStruct t1, TempStruct t2)
        {
            return new TempStruct(t1.value * t2.value);
        }
    }


    [TestMethod]
    public void TestDouble()
    {
        double doubleValue = 100;
        TempStruct t = new TempStruct();
        TempStruct Tres= new TempStruct(100);
        TempClass tclass = new TempClass(100);
        double res;

        var watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res = doubleValue*doubleValue;
        }

        watch.Stop();

        var elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multply doubles "+ elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            Tres.value = t.value * t.value;
        }

        watch.Stop();


        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multply struct fields " + elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            Tres.GetTemp = t.GetTemp * t.GetTemp;
        }

        watch.Stop();


        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multply struct property " + elapsedMs.ToString());


        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            Tres = t * t;
        }

        watch.Stop();

        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multply temperature struct using overloaded * operator " + elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res = tclass.value * tclass.value;
        }

        watch.Stop();
        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multply class fields " + elapsedMs.ToString());
    }


    [TestMethod]
    public void TestDoubleArray()
    {
        double doublevalue = 100;
        TempStruct t = new TempStruct();
        TempStruct Tres = new TempStruct(100);
        TempClass tclass = new TempClass(100);
        object[] res = new object[10000000];

        var watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = doublevalue * doublevalue;
        }

        watch.Stop();

        var elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply & Load doubles into object array " + elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = t.value * t.value;
        }

        watch.Stop();


        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply struct fields & Load into object array " + elapsedMs.ToString());


        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = new TempStruct(t.value * t.value);
        }

        watch.Stop();


        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply struct fields & Load new struct into object array " + elapsedMs.ToString());



        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = t * t;
        }

        watch.Stop();

        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply structs with overloaded operator a load struct into object array " + elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = tclass.value * tclass.value;
        }

        watch.Stop();
        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply class fields & load into object array " + elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = new TempClass(tclass.value * tclass.value);
        }

        watch.Stop();
        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply class fields & load new class into object array " + elapsedMs.ToString());

        watch = Stopwatch.StartNew();

        for (int i = 0; i < 10000000; i++)
        {
            res[i] = tclass * tclass;
        }

        watch.Stop();
        elapsedMs = watch.ElapsedMilliseconds;
        Debug.WriteLine("Multiply class using overloaded * operator & load class into object array " + elapsedMs.ToString());
    }
}    

公共类测试速度
{
公共课临时课
{
公共双值=100；
私人双v；
公共临时班（双v）
{
这个，v=v；
}
公共静态临时类运算符*（临时类t1、临时类t2）
{
返回新的TempClass（t1.value*t2.value）；
}
}
公共结构TempStruct
{
公共双重价值；
公共临时结构（双v）
{
值=v；
}
公共双GetTemp
{
获取{返回值；}
设置{this.value=value；}
}
公共静态TempStruct运算符*（TempStruct t1、TempStruct t2）
{
返回新的TempStruct（t1.value*t2.value）；
}
}
[测试方法]
公共void TestDouble（）
{
双倍值=100；
TempStruct t=新的TempStruct（）；
TempStruct Tres=新的TempStruct（100）；
TempClass tclass=新的TempClass（100）；
双res；
var watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res=双值*双值；
}
看，停；
var elapsedMs=watch.elapsedmillisons；
WriteLine（“Multply doubles”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
Tres.value=t.value*t.value；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“Multply struct fields”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
Tres.GetTemp=t.GetTemp*t.GetTemp；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“Multply struct property”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
Tres=t*t；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“使用重载*运算符的Multply-temperature结构”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res=tclass.value*tclass.value；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“Multply类字段”+elapsedMs.ToString（））；
}
[测试方法]
公共void TestDoubleArray（）
{
双倍值=100；
TempStruct t=新的TempStruct（）；
TempStruct Tres=新的TempStruct（100）；
TempClass tclass=新的TempClass（100）；
object[]res=新对象[10000000]；
var watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res[i]=双值*双值；
}
看，停；
var elapsedMs=watch.elapsedmillisons；
Debug.WriteLine（“乘法并将doubles加载到对象数组”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res[i]=t.value*t.value；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“Multiply struct fields&Load to object array”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res[i]=新的TempStruct（t.value*t.value）；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“乘法结构字段并将新结构加载到对象数组”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res[i]=t*t；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“使用重载运算符乘法结构并将结构加载到对象数组”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res[i]=tclass.value*tclass.value；
}
看，停；
elapsedMs=watch.ElapsedMilliseconds；
WriteLine（“Multiply class fields&load to object array”+elapsedMs.ToString（））；
watch=Stopwatch.StartNew（）；
对于（int i=0；i<10000000；i++）
{
res[i]=新的TempClass（tclass.value*tclass.value）；
}