C# 性能：整数vs.字节vs.自定义整数
我正在写一个程序，其中我需要一对值始终是一个从0到255的值，我想把它们限制在255。我想知道我的最佳选择是什么，性能方面：C# 性能：整数vs.字节vs.自定义整数,c#,performance,C#,Performance,我正在写一个程序，其中我需要一对值始终是一个从0到255的值，我想把它们限制在255。我想知道我的最佳选择是什么，性能方面： int，我必须在整个代码中进行大量检查 字节，将引发异常，因此我仍需要检查 自定义int，可编程为自动降低值或将值增加到我想要的值，但可能缺乏性能（不确定） 哪种选择最适合我的情况？（也欢迎其他建议）对于这样的事情，我的第一个想法不是关于性能，而是关于可用性。如果对代码没有更好的理解，性能影响将很难衡量，最终分析器将成为更改的真正评判者。相反，我将专注于使其易于使用，
- int，我必须在整个代码中进行大量检查
- 字节，将引发异常，因此我仍需要检查
- 自定义int，可编程为自动降低值或将值增加到我想要的值，但可能缺乏性能（不确定）
哪种选择最适合我的情况？（也欢迎其他建议）对于这样的事情，我的第一个想法不是关于性能，而是关于可用性。如果对代码没有更好的理解，性能影响将很难衡量，最终分析器将成为更改的真正评判者。相反，我将专注于使其易于使用，然后测试该解决方案的性能 在这里有一个自定义类型似乎并不不合理。想必你会想把每一个单独的操作都限制在255，而不是限制最终结果。例如，255+100-50应该等于205而不是255。如果是这样的话，自定义类型是您的最佳选择，可以按照以下方式实现
struct MyInt {
public readonly int Value;
public MyInt(int value) {
Value = Math.Min(value, 255);
}
public static MyInt operator+(MyInt left, MyInt right) {
return new MyInt(left.Value + right.Value);
}
public static MyInt operator-(MyInt left, MyInt right) {
return new MyInt(left.Value - right.Value);
}
// etc ...
}
注意，在这种类型下，您也应该考虑实现接口，例如“代码>可写的< /代码>，<代码>可比较的和<代码> IEQuabtI/<代码>
< p>对于这样的事情，我的第一个想法不是关于性能而是关于可用性。如果对代码没有更好的理解，性能影响将很难衡量，最终分析器将成为更改的真正评判者。相反，我将专注于使其易于使用，然后测试该解决方案的性能 在这里有一个自定义类型似乎并不不合理。想必你会想把每一个单独的操作都限制在255，而不是限制最终结果。例如，255+100-50应该等于205而不是255。如果是这样的话，自定义类型是您的最佳选择，可以按照以下方式实现struct MyInt {
public readonly int Value;
public MyInt(int value) {
Value = Math.Min(value, 255);
}
public static MyInt operator+(MyInt left, MyInt right) {
return new MyInt(left.Value + right.Value);
}
public static MyInt operator-(MyInt left, MyInt right) {
return new MyInt(left.Value - right.Value);
}
// etc ...
}
注意，在这种类型下，您也应该考虑实现接口，例如“代码>可写的< /代码>，<代码>可比较的和<代码> IEQuabtI/<代码>
< p>对于这样的事情，我的第一个想法不是关于性能而是关于可用性。如果对代码没有更好的理解，性能影响将很难衡量，最终分析器将成为更改的真正评判者。相反，我将专注于使其易于使用，然后测试该解决方案的性能 在这里有一个自定义类型似乎并不不合理。想必你会想把每一个单独的操作都限制在255，而不是限制最终结果。例如，255+100-50应该等于205而不是255。如果是这样的话，自定义类型是您的最佳选择，可以按照以下方式实现struct MyInt {
public readonly int Value;
public MyInt(int value) {
Value = Math.Min(value, 255);
}
public static MyInt operator+(MyInt left, MyInt right) {
return new MyInt(left.Value + right.Value);
}
public static MyInt operator-(MyInt left, MyInt right) {
return new MyInt(left.Value - right.Value);
}
// etc ...
}
注意，在这种类型下，您也应该考虑实现接口，例如“代码>可写的< /代码>，<代码>可比较的和<代码> IEQuabtI/<代码>
< p>对于这样的事情，我的第一个想法不是关于性能而是关于可用性。如果对代码没有更好的理解，性能影响将很难衡量，最终分析器将成为更改的真正评判者。相反，我将专注于使其易于使用，然后测试该解决方案的性能 在这里有一个自定义类型似乎并不不合理。想必你会想把每一个单独的操作都限制在255，而不是限制最终结果。例如，255+100-50应该等于205而不是255。如果是这样的话，自定义类型是您的最佳选择，可以按照以下方式实现struct MyInt {
public readonly int Value;
public MyInt(int value) {
Value = Math.Min(value, 255);
}
public static MyInt operator+(MyInt left, MyInt right) {
return new MyInt(left.Value + right.Value);
}
public static MyInt operator-(MyInt left, MyInt right) {
return new MyInt(left.Value - right.Value);
}
// etc ...
}
注意，在这种类型下，您还应该考虑实现接口，如“代码>可计算的< /代码>，<代码>可计算的和<代码> IEQuabtI/<代码> < /P>“字节，将引发异常，所以我仍然需要检查”。-你的意思是什么例外？基准测试并亲自查看faster@astef哦，我可能会把它与其他东西混淆，但我的印象是，当你分配一个超出范围的值时，它会抛出一个异常？@MikeSW我不知道怎么做，这正是我要求它使用Stopwatch类的原因。顺便说一句，在99.9999999%的情况下，自定义int和int永远不会成为性能瓶颈。“byte会引发异常，所以我仍然需要检查”-什么是异常？基准测试，自己看看哪个是faster@astef哦，我可能把它和别的东西混淆了，但我的印象是，当你分配一个超出范围的值时，它会抛出一个异常？@MikeSW我不知道怎么做，这正是我要求它使用Stopwatch类的原因。顺便说一句，在99.9999999%的情况下，自定义int和int永远不会成为性能瓶颈。“byte会引发异常，所以我仍然需要检查”-什么是异常？基准测试，自己看看哪个是faster@astef哦，我可能把它和别的东西混淆了，但我的印象是，当你分配一个超出范围的值时，它会抛出一个异常？@MikeSW我不知道怎么做，这正是我要求它使用Stopwatch类的原因。顺便说一句，在99.9999999%的情况下，自定义int和int永远不会成为性能瓶颈。“byte会引发异常，所以我仍然需要检查”-什么是异常？基准测试，自己看看哪个是faster@astef哦，我可能把它和别的东西混淆了，但我的印象是，当你分配一个超出范围的值时，它会抛出一个异常？@MikeSW我不知道怎么做，这正是我要求它使用Stopwatch类的原因。顺便说一句，在99.9999999%的情况下，自定义int和int永远不会成为性能瓶颈method@MikeSW可通过
值readonly