设置没有反射的只读字符串

Question

我正在开发一个需要访问公共字符串的应用程序。 但是，我也希望限制写访问。由于我有很多字符串，我想避免每个字符串都有一个 getter 和 private setter。

见下面的代码：

public readonly string privateMem, peakVM, peakPaged, pagedSysMem, pagedMem, nonpagedSysMem;

    public override void Capture()
    {
        using (Process p = Process.GetCurrentProcess())
        {

            // Throws error as privateMem can't be assigned a value

            privateMem = string.Format("{0:N0} K", p.PrivateMemorySize64 / 1024);
            peakVM = string.Format("{0:N0} K", p.PeakVirtualMemorySize64 / 1024);
            peakPaged = string.Format("{0:N0} K", p.PeakPagedMemorySize64 / 1024);
            pagedSysMem = string.Format("{0:N0} K", p.PagedSystemMemorySize64 / 1024);
            pagedMem = string.Format("{0:N0} K", p.PagedMemorySize64 / 1024);
            nonpagedSysMem = string.Format("{0:N0} K", p.NonpagedSystemMemorySize64 / 1024);
        }

    }    

我知道有一些方法可以通过反射为只读字段分配值，但是我从其他几个 stackoverflow 问题中收集到，这是一个糟糕的主意。

总之：

1。 如何在没有反射的情况下为只读字符串赋值，或者在不使用详细的 getter 和 setter 的情况下是否存在更好的解决方案？

2。 有没有办法声明一个变量，为其赋值，然后将其指定为只读？

Answer 1

您尝试做的事情毫无意义。只读字段只能在构造函数中填充。它们对于依赖注入非常有用，例如，事物只在构造函数内部设置，仅此而已，不能在它之外进行修改。

例如，您始终可以使用私有集。说 getter 和 setter 是“冗长的”也是没有意义的。他们在那里是有原因的。试图找到一种以不同方式做事的方法很可能意味着疯狂的代码，而这一切只是为了避免使用简单的 setter？

想想你在做什么以及为什么，然后最后问自己，这真的值得吗？

Answer 2

您当前使用字典的答案不正确，因为它不是只读的。

更正确的方法是基于字典初始化 IReadOnlyDictionary（在 .NET 4.5 或更高版本中）实例一次，并添加逻辑以防止它在初始化后被新值覆盖。

通过使用支持字段，我们可以确保即使在类内部尝试修改它，一旦它包含值就不会被覆盖。

private IReadOnlyDictionary<string, string> _memoryStrings;
public IReadOnlyDictionary<string, string> memoryStrings
{
    get
    {
        return _memoryStrings;
    }
    private set
    {
        if (_memoryStrings != null && _memoryStrings.Count() > 0) return;
        _memoryStrings = value;
    }
}

public void Capture()
{
    if (memoryStrings == null || memoryStrings.Count() == 0)
    {
        using (Process p = Process.GetCurrentProcess())
        {
            memoryStrings = new Dictionary<string, string>
            {
                {"privateMem", string.Format("{0:N0} K", p.PrivateMemorySize64 / 1024)},
                {"peakVm", string.Format("{0:N0} K", p.PeakVirtualMemorySize64 / 1024)},
                {"peakPaged", string.Format("{0:N0} K", p.PeakPagedMemorySize64 / 1024)},
                {"pagedSysMem", string.Format("{0:N0} K", p.PagedSystemMemorySize64 / 1024)},
                {"pagedMem", string.Format("{0:N0} K", p.PagedMemorySize64 / 1024)},
                { "nonpagedSysMem", string.Format("{0:N0} K", p.NonpagedSystemMemorySize64 / 1024)}
            };
        }
    }
}

这为我们提供了多个级别的不变性。

如果您多次调用Capture()，它只会在第一次运行计算。

如果您尝试在类中的其他位置覆盖字典，一旦它包含值就不会被覆盖。

如果您在创建集合后尝试覆盖属性或添加值，您将收到编译时异常（在使用索引器或尝试使用 .Add() 方法的情况下）或运行时异常（在通过转换为IDictionary 使用.Add() 方法的情况下）。

Answer 3

我最终只使用了字典。这样我只需要一个 getter 和一个私有 setter，而且以后添加更多字符串/系统信息时它的可扩展性要大得多。

public Dictionary<string, string> memoryStrings
         {
             get;
             private set;
         }

        public MemoryUsageFragment() {
            memoryStrings = new Dictionary<string, string>();
        }

        public override void Capture()
        {
            using (Process p = Process.GetCurrentProcess())
            {
                memoryStrings.Add("privateMem", string.Format("{0:N0} K", p.PrivateMemorySize64 / 1024));
                memoryStrings.Add("peakVm", string.Format("{0:N0} K", p.PeakVirtualMemorySize64 / 1024));
                memoryStrings.Add("peakPaged", string.Format("{0:N0} K", p.PeakPagedMemorySize64 / 1024));
                memoryStrings.Add("pagedSysMem", string.Format("{0:N0} K", p.PagedSystemMemorySize64 / 1024));
                memoryStrings.Add("pagedMem", string.Format("{0:N0} K", p.PagedMemorySize64 / 1024));
                memoryStrings.Add("nonpagedSysMem", string.Format("{0:N0} K", p.NonpagedSystemMemorySize64 / 1024));
            }    
        }

Answer 4

public string privateMem        { get; private set; }
public string peakVM            { get; private set; }
public string peakPaged         { get; private set; }
public string pagedSysMem       { get; private set; }
public string pagedMem          { get; private set; }
public string nonpagedSysMem    { get; private set; }

这总共花了大约 20 秒。这有什么好说的？