参数可以恒定吗？

Question

我正在寻找 Java 的 final 的 C# 等效项。它存在吗？

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.
}

Answer 1

不幸的是，您无法在 C# 中执行此操作。

const 关键字只能用于局部变量和字段。

readonly 关键字只能在字段上使用。

注意：Java 语言还支持方法具有最终参数。 C# 中不存在此功能。

来自 http://www.25hoursaday.com/CsharpVsJava.html

编辑（2019/08/13 ）：
我将其放入以提高可见性，因为它已被接受并且在列表中名列前茅。现在可以使用 in 参数来实现。有关详细信息，请参阅下面的答案。

Answer 2

现在，这在 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;
}

尝试修改 x 或 y 时将显示以下错误，因为它们被标记为 在：

无法分配给变量“in long”，因为它是只读变量

用 in 标记参数意味着：

此方法不会修改用作此参数的参数的值。

Answer 3

答案：C# 没有像 C++ 那样的 const 功能。

我同意贝内特·迪尔的观点。

const 关键字非常有用。在示例中，您使用了 int，但人们不明白您的意思。但是，为什么如果您的参数是一个用户巨大且复杂的对象，并且无法在该函数内更改呢？这就是 const 关键字的使用：参数不能在该方法内更改，因为[无论此处的原因]这对该方法并不重要。 Const 关键字非常强大，我真的很怀念 C# 中的它。

Answer 4

这是一个简短而甜蜜的答案，可能会得到很多反对票。我还没有阅读所有的帖子和评论，所以如果之前有人建议过，请原谅我。

为什么不将参数传递给一个将它们公开为不可变的对象，然后在您的方法中使用该对象呢？

我意识到这可能是一个非常明显的解决方法，已经被考虑过，并且OP试图通过提出这个问题来避免这样做，但我觉得它应该在这里......祝你好运

:-)

Answer 5

我将从 int 部分开始。 int 是一种值类型，在 .Net 中这意味着您实际上正在处理一个副本。告诉一个方法“你可以拥有这个值的副本。这是你的副本，不是我的；我再也不会看到它了。但你不能更改副本”，这是一个非常奇怪的设计约束。在方法调用中隐含的是复制这个值是可以的，否则我们无法安全地调用该方法。如果该方法需要原件，则留给实现者复制一份保存。要么为该方法提供值，要么不为该方法提供值。不要在这两者之间表现得软弱无力。

让我们继续讨论引用类型。现在有点令人困惑。您是指引用本身无法更改的常量引用，还是完全锁定的、不可更改的对象？如果是前者，.Net 中的引用默认按值传递。也就是说，您将获得参考的副本。所以我们的情况本质上与值类型相同。如果实施者需要原始参考，他们可以自己保留。

这只会给我们留下不变的（锁定/不可变的）对象。从运行时的角度来看，这似乎没问题，但是编译器如何强制执行它呢？由于属性和方法都可能产生副作用，因此您基本上只能进行只读字段访问。这样的物体不太可能很有趣。

Answer 6

为您的类创建一个仅具有只读属性访问器的接口。然后让您的参数属于该接口而不是类本身。示例：

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
}

对于结构，创建一个通用 const 包装器。

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
}

但值得注意的是，您想要对结构执行您要求执行的操作，这很奇怪，作为方法的编写者，您应该期望知道该方法中发生了什么。它不会影响传入的值以在方法中修改它们，因此您唯一关心的是确保您在编写的方法中表现良好。到了某个时候，警惕和干净的代码就成为关键，而不是强制执行 const 和其他类似的规则。

Answer 7

我知道这可能有点晚了。
但对于仍在寻找其他方法的人来说，可能还有另一种方法可以绕过 C# 标准的这一限制。
我们可以编写包装类 ReadOnly其中 T ：结构。
隐式转换为基类型 T。
但只有显式转换为wrapper班级。
如果开发人员尝试隐式设置为 ReadOnly的值，这将强制编译器错误。类型。
我将在下面演示两种可能的用途。

用法 1 需要更改调用者定义。此用法仅用于测试“TestCalled”函数代码的正确性。在发布级别/构建时，您不应该使用它。因为在大规模数学运算中可能会过度转换，并使代码变慢。我不会使用它，但出于演示目的，我发布了它。

我建议的用法 2 在 TestCalled2 函数中演示了调试与发布的使用。使用此方法时，TestCaller 函数中也不会进行转换，但需要使用编译器条件对 TestCaller2 定义进行更多编码。您可以注意到调试配置中的编译器错误，而在发布配置中 TestCalled2 函数中的所有代码都将成功编译。

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;
  }

}

Answer 8

如果您经常遇到这样的麻烦，那么您应该考虑“匈牙利应用程序”。好的类型，而不是坏的类型。虽然这通常不会尝试表达方法参数的恒定性（这太不寻常了），但肯定没有什么可以阻止您在标识符名称之前添加额外的“c”。

对于所有现在渴望按下否决按钮的人，请阅读这些名人对这个主题的看法：

• 埃里克·利珀特
• 拉里·奥斯特曼
• 乔尔·斯波尔斯基

Answer 9

如果 struct 被传递到方法中，除非它是通过 ref 传递的，否则它不会被传递到的方法更改。所以从这个意义上说，是的。

您是否可以创建一个参数，其值无法在方法内分配，或者其属性无法在方法内设置？不可以。您无法阻止在方法内分配值，但可以通过创建不可变类型来阻止设置其属性。

问题不在于参数或其属性是否可以在方法内分配。问题是当该方法退出时会发生什么。

任何外部数据唯一会被更改的情况是，如果您传入一个类并更改其属性之一，或者如果您使用 ref 关键字传递一个值。你所描述的情况两者都没有。

Answer 10

建议（好吧，我）是使用一个为成员提供只读访问权限的界面。请记住，如果“真实”成员是引用类型，则仅提供对支持该类型的读取操作的接口的访问——递归到整个对象层次结构。