我正在寻找C#中类似Java的final的等价物。它存在吗？
C#是否有类似以下内容的东西：
public Foo(final int bar);
bar 是一个只读变量，不能被 Foo() 改变。在 C# 中有没有任何方法可以实现这个？x、y 和 z 坐标（整数）。我想要确保该函数不以任何方式改变这些值，从而破坏数据。因此，我想将它们声明为只读。public Foo(int x, int y, int z) {
// do stuff
x++; // oops. This corrupts the data. Can this be caught at compile time?
// do more stuff, assuming x is still the original value.
}
不幸的是，您无法在C＃中进行此操作。
const 关键字只能用于局部变量和字段。
readonly 关键字只能用于字段。
注：Java语言还支持将参数设置为final。这种功能在C＃中不存在。
来自http://www.25hoursaday.com/CsharpVsJava.html
编辑（2019/08/13）：
我在这里增加可见性，因为它被接受并且排在首位。现在使用in参数有点可能实现此操作。有关详细信息，请参见下面的答案。
int，double，struct。请注意，C#中的struct与C++中的struct是不同的。 - John Saunders在C# 7.2版本中，现在可以这样做：
您可以在方法签名中使用in关键字。 MSDN文档
在指定方法参数之前应添加in关键字。
例如，在C# 7.2中，以下是一个有效的方法：
public long Add(in long x, in long y)
{
return x + y;
}
虽然以下是不允许的：
public long Add(in long x, in long y)
{
x = 10; // It is not allowed to modify an in-argument.
return x + y;
}
当尝试修改标记为in的x或y时，将显示以下错误：
无法分配给变量“in long”，因为它是只读变量
使用in标记参数的含义是:
该方法不会修改用作此参数的参数的值。
in关键字作为这些类型参数的情况，只能防止将其赋值给其他变量，而不能防止修改其可访问的字段或属性！我的理解正确吗？ - ABS以下是一个简短而简单的答案，可能会得到很多反对意见。如果此前已经有人提出了这个建议，请原谅我，因为我没有阅读所有的帖子和评论。
为什么不将您的参数传递到一个对象中，该对象将其公开为不可变对象，然后在您的方法中使用该对象？
我知道这可能是一个非常明显的解决方法，已经被考虑过了，而且OP正在通过提问来避免这样做，但我认为它应该在这里出现...
祝好运 :-)
int* p; *p = 0;。这将编译并运行，直到发生分段错误。 - Cole Tobin为你的类创建一个仅具有只读属性访问器的接口。然后将你的参数设置为该接口，而不是类本身。例如：
public interface IExample
{
int ReadonlyValue { get; }
}
public class Example : IExample
{
public int Value { get; set; }
public int ReadonlyValue { get { return this.Value; } }
}
public void Foo(IExample example)
{
// Now only has access to the get accessors for the properties
}
public struct Const<T>
{
public T Value { get; private set; }
public Const(T value)
{
this.Value = value;
}
}
public Foo(Const<float> X, Const<float> Y, Const<float> Z)
{
// Can only read these values
}
需要注意的是，关于结构体 (structs) 的操作并不常见。作为方法的编写者，您应该知道方法内部发生了什么。在方法内修改传入的值不会影响其原始值，所以您唯一需要关注的是在编写方法时确保自己的行为合适。在保持警惕和编写干净代码的同时，强制执行 const 和其他规则也很重要。
int部分开始。 int是一种值类型，在.NET中意味着你真的在处理一个副本。告诉方法“您可以拥有此值的副本。这是您的副本，不是我的;我再也看不到它了。但您不能更改该副本”，这是一个非常奇怪的设计约束。 方法调用中隐含了复制这个值是可以的，否则我们无法安全地调用该方法。如果方法需要原始值，请让实现者复制以保存它。要么给方法提供该值，要么不给方法提供该值。不要在两者之间摇摆不定。using System;
using System.Collections.Generic;
public class ReadOnly<VT>
where VT : struct
{
private VT value;
public ReadOnly(VT value)
{
this.value = value;
}
public static implicit operator VT(ReadOnly<VT> rvalue)
{
return rvalue.value;
}
public static explicit operator ReadOnly<VT>(VT rvalue)
{
return new ReadOnly<VT>(rvalue);
}
}
public static class TestFunctionArguments
{
static void TestCall()
{
long a = 0;
// CALL USAGE 1.
// explicite cast must exist in call to this function
// and clearly states it will be readonly inside TestCalled function.
TestCalled(a); // invalid call, we must explicit cast to ReadOnly<T>
TestCalled((ReadOnly<long>)a); // explicit cast to ReadOnly<T>
// CALL USAGE 2.
// Debug vs Release call has no difference - no compiler errors
TestCalled2(a);
}
// ARG USAGE 1.
static void TestCalled(ReadOnly<long> a)
{
// invalid operations, compiler errors
a = 10L;
a += 2L;
a -= 2L;
a *= 2L;
a /= 2L;
a++;
a--;
// valid operations
long l;
l = a + 2;
l = a - 2;
l = a * 2;
l = a / 2;
l = a ^ 2;
l = a | 2;
l = a & 2;
l = a << 2;
l = a >> 2;
l = ~a;
}
// ARG USAGE 2.
#if DEBUG
static void TestCalled2(long a2_writable)
{
ReadOnly<long> a = new ReadOnly<long>(a2_writable);
#else
static void TestCalled2(long a)
{
#endif
// invalid operations
// compiler will have errors in debug configuration
// compiler will compile in release
a = 10L;
a += 2L;
a -= 2L;
a *= 2L;
a /= 2L;
a++;
a--;
// valid operations
// compiler will compile in both, debug and release configurations
long l;
l = a + 2;
l = a - 2;
l = a * 2;
l = a / 2;
l = a ^ 2;
l = a | 2;
l = a & 2;
l = a << 2;
l = a >> 2;
l = ~a;
}
}
如果将结构体传递到方法中，除非通过引用传递，否则它不会被传递到的方法更改。从这个意义上说，是的。
您能创建一个参数，其值无法在方法内分配或其属性不能在方法内设置吗？不行。您无法防止在方法内分配该值，但可以通过创建不可变类型来防止其属性被设置。
问题不在于参数或其属性是否可以在方法内分配。问题是当方法退出时它将是什么。
唯一会改变任何外部数据的时间是如果您传递一个类并更改其中一个属性，或者使用ref关键字传递一个值。您概述的情况都没有。
x++。也就是说，他试图防止重新分配参数，这与参数值的可变性无关。 - itowlson我的建议是使用一个提供只读成员访问的接口（至少我觉得是这样）。请记住，如果“真正”的成员是引用类型，则仅为该类型支持读操作的接口提供访问权限--递归下整个对象层次结构。