制作只读本地字符串 C#

Question

我有一个本地字符串（文件路径），我只需要从函数中检索一次，我想确保它不再被修改。我不能使用const 关键字，因为我的字符串的值是在运行时而不是编译时确定的。所以我尝试改用 readonly 关键字，但 Visual Studio 告诉我它对我的项目无效。我怎样才能达到我想要的保护水平，最好不要再上课？

为了简单起见和公司政策，我（大幅）缩小并重命名了我的类和函数，但概念是相同的。

public class myClass
{
    private void myFunction()
    {
      readonly string filePath = HelperClass.getFilePath("123");

     //do stuff
    }
}

public static class HelperClass
{ 
    public static string getFilePath(string ID)
    {
        switch(ID)
        {
             case "123":
                 return "C:/123.txt";

             case "234":
                 return "C:/234.txt";

             default:
                 throw new Exception(ID + " is not supported");
        }
    }
}

=== 为 PS2Goat 编辑 ====

public class myClass
{
    protected SomeObject o;
    private virtual readonly string path;        

    public myClass(someObject o)
    {
        this.o = o;
        path = HelperClass.getFilePath(o.getID());
    }

    private virtual void myFunction()
    { 

     //do stuff
    }
}

public class myDerivedClass
{
    private override virtual readonly string path;        

    public myDerivedClass(someObject o) : base(o)
    {
        path = HelperClass.getFilePath(o.getID()); //ID will be different
    }

    private override void myFunction()
    { 

     //do different stuff
    }
}





public static class HelperClass
{ 
    public static string getFilePath(string ID)
    {
        switch(ID)
        {
             case "123":
                 return "C:/123.txt";

             case "234":
                 return "C:/234.txt";

             default:
                 throw new Exception(ID + " is not supported");
        }
    }
}

看，所以我遇到的这个问题是，如果我想抛出异常，我现在必须在父类的构造函数中捕获它（直到支持该类），因为父构造函数将是在派生构造函数之前调用。因此，在调用子构造函数（具有正确 ID）之前，将设置一次错误的 ID。

Answer 1

您不能在方法内设置只读变量。因此应该将其提升为readonly static 字段：

public class myClass
{
    private readonly static string filePath = HelperClass.getFilePath("123");
    private void myFunction()
    {    
      //do stuff
    }
}

这将导致您的filePath 变量在第一次访问myClass 时被初始化。如果这不是您想要的，getFilePath 是一个长时间运行/昂贵的操作，并且您想等到myFunction 被调用，您可以将实现替换为System.Lazy<T>：

public class myClass
{
    private readonly static Lazy<string> filePath 
            = new Lazy<string>(() => HelperClass.getFilePath("123")));
    private void myFunction()
    {   
      string path = filePath.Value;
      //do stuff
    }
}

Answer 2

readonly 表示它只能在类构造函数或实例化中设置。所以，你可以把你的逻辑改成这样：

public class myClass
{
    private readonly string _filePath;

    public myClass()
    {
        _filePath = HelperClass.getFilePath("123");
    }

    private void myFunction()
    {
      // Use your _filePath here...

     //do stuff
    }
}

public static class HelperClass
{ 
    public static string getFilePath(string ID)
    {
        switch(ID)
        {
             case "123":
                 return "C:/123.txt";

             case "234":
                 return "C:/234.txt";

             default:
                 throw new Exception(ID + " is not supported");
        }
    }
}

Answer 3

您可以将要在函数定义之外声明的 readonly 变量移动。

public class myClass
    {
        readonly string filePath = HelperClass.getFilePath("123");

        private void myFunction()
        {

         //do stuff with filePath
        }
    }

Answer 4

由于这是一个变量而不是字段或属性，因此您不能将其标记为只读。但是，您可以通过使用匿名类型来“欺骗”并实现您想要的，这可以确保其属性是只读的。

例如：

    var data = new
    {
        FileName = HelperClass.getFilePath("123");
    };

Answer 5

将filePath 变量提升为字段，这应该可以修复错误。局部变量不能是只读的。

public class myClass
{
      readonly string filePath = HelperClass.getFilePath("123");
}