参数可以恒定吗？

Question 1

我正在寻找与Java等效的C＃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.
}

Question 2

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

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

该readonly关键字只能领域。

注意：Java语言还支持对方法使用最终参数。C＃中不存在此功能。

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

编辑（2019/08/13）：我将其扔进去以提高知名度，因为它被接受并且在列表中排名最高。现在可以使用in参数了。有关详细信息，请参见此答案下面的答案。

Question 3

现在在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：

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

用以下in方式标记参数：

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

Question 4

这是一个简短而甜蜜的答案，可能会得到很多反对。我尚未阅读所有帖子和评论，因此，如果以前曾建议这样做，请原谅我。

为什么不采用您的参数并将其传递到一个将其暴露为不可变的对象，然后在您的方法中使用该对象呢？

我意识到这可能是已经考虑过的非常明显的解决方案，OP试图通过问这个问题来避免这样做，但是我仍然认为应该在这里...

祝好运：-）

Question 5

答案：C＃没有像C ++这样的const功能。

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

const关键字非常有用。在该示例中，您使用了一个int，但是人们并没有理解您的意思。但是，为什么要声明参数是一个用户巨大且复杂的对象，而该对象无法在该函数内更改？那就是使用const关键字：该方法内部的参数无法更改，因为[无论出于何种原因]对该方法都无关紧要。const关键字非常强大，我真的很想念C＃。

Question 6

我将从这int部分开始。 int是一个值类型，在.Net中，这意味着您确实在处理副本。告诉方法“这是一个非常奇怪的设计约束”，您可以拥有该值的副本。这是您的副本，而不是我的；我再也不会看到它。但是您无法更改副本。方法调用中隐含了可以复制此值的方法，否则我们无法安全地调用该方法。如果该方法需要原始方法，则将其留给实现者进行复制以保存。给方法赋值或不给方法赋值。在这两者之间不要全力以赴。

让我们继续参考类型。现在有点混乱了。您是指常量引用，而引用本身无法更改，还是完全锁定的，不可更改的对象？如果是前者，则默认情况下按值传递.Net中的引用。也就是说，您将获得参考的副本。因此，我们基本上具有与值类型相同的情况。如果实施者需要原始参考，他们可以自己保留它。

这就给我们留下了常量（锁定/不可变）的对象。从运行时的角度来看这似乎还可以，但是编译器如何执行它呢？由于属性和方法都会产生副作用，因此从本质上讲，您将仅限于只读字段访问。这样的对象可能不太有趣。

Question 7

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

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和其他此类规则方面，警惕性和整洁的代码是关键。

Question 8

如果您经常遇到这样的麻烦，则应考虑“匈牙利应用”。好种类，而不是坏种类。尽管这通常不会尝试表示方法参数的常数（这太不寻常了），但是肯定没有什么可以阻止您在标识符名称前加上一个额外的“ c”。

现在，对于所有渴望猛烈按下downvote按钮的人们，请阅读以下有关这些主题的专家的意见：

Question 9

我知道这可能会晚一点。但是对于仍在寻找其他方法的人们，可能还有另一种方法可以解决C＃标准的这一局限性。我们可以编写包装类ReadOnly <T>，其中T：struct。隐式转换为基本类型T。但仅显式转换为wrapper <T>类。如果开发人员尝试将值隐式设置为ReadOnly <T>类型的值，则会强制执行编译器错误。正如我将在下面演示两种可能的用法。

用法1要求更改呼叫者定义。此用法仅用于测试“ TestCalled”功能代码的正确性。在发行版/构建中，您不应使用它。因为在大规模情况下，数学运算可能会过度转换，从而使您的代码运行缓慢。我不会使用它，但仅出于演示目的，我已将其发布。

我建议使用的用法2在TestCalled2函数中演示了Debug vs Release的用法。使用这种方法时，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;
  }

}

Question 10

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

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

问题不在于是否可以在方法中将参数或其属性分配给它。问题是方法退出时将是什么。

唯一可以更改外部数据的情况是，如果您传入一个类并更改其属性之一，或者您使用ref关键字传递了一个值。您概述的情况都不会。