时间:2019-03-07 标签:c#

Question

所以我必须定期调用一个方法作为模式的一部分。它看起来像这样:

DoWork(new TimeSpan(0, 0, 2, 0));

或者在代码的另一部分:

DoWork(new TimeSpan(0, 0, 6, 50));

在每种情况下，参数都不会改变，我最近醒来并发现为每个调用不断创建参数对性能来说是多么大的打击。我的解决方案是这样的:

// instance field
TimeSpan _cachedValue = new TimeSpan(0, 0, 2, 0);
// and when called, 
DoWork(this._cachedValue)

这一切都非常明显，但我遇到的问题是将参数值存储在一个字段中......它很困惑 - 在一个已经臃肿的类中(例如，在一个类中，我会使用以下命令调用 do work 方法)大约 10 个变体，每个变体数千次 - 因此有 10 个额外字段)。

如果我能做这样的事情那就太酷了:

DoWork([DoesNotChange()]new TimeSpan(0, 0, 2, 0));

参数的这一理论属性表明，对于该特定调用，该值只需要计算一次，然后重复传递给方法。

那么这样的事情可能吗？还是我疯了？

干杯

编辑:

哇，你们工作得真快，谢谢。至于我的问题，我上次应该学会不要过度简化 - 抱歉。为了清楚起见，我将发布一个实际的代码片段。此类用于 Silverlight 应用程序中的数据绑定(bind)。为了可维护性，我对 PropertyChanged 事件使用强类型:

internal class BasicDataClass : INotifyPropertyChanged
{
    private readonly Expression<Func<double>> _propertySelector;
    private double _someFieldA;
    private double _someFieldB;
    private double _someFieldC;

    public BasicDataClass()
    {
        _propertySelector = () => SomeFieldC;
    }

    /// <summary>
    /// This is fastest
    /// </summary>
    public double SomeFieldA
    {
        get { return _someFieldA; }
        set
        {
            if (!_someFieldA.Equals(value))
            {
                _someFieldA = value;
                PropertyChanged.Raise(this, "SomeFieldA");
            }
        }
    }

    /// <summary>
    /// This is many times slower
    /// </summary>
    public double SomeFieldB
    {
        get { return _someFieldB; }
        set
        {
            if (!_someFieldB.Equals(value))
            {
                _someFieldB = value;
                PropertyChanged.Raise(() => SomeFieldB);
            }
        }
    }

    /// <summary>
    /// This is only, very slightly slower than A
    /// but requires an extra field
    /// </summary>
    public double SomeFieldC
    {
        get { return _someFieldC; }
        set
        {
            if (!_someFieldC.Equals(value))
            {
                _someFieldC = value;
                PropertyChanged.Raise(_propertySelector);
            }
        }
    }

    #region INotifyPropertyChanged Members

    /// <summary>
    /// The property changed.
    /// </summary>
    public event PropertyChangedEventHandler PropertyChanged;

    #endregion
}

作为引用，Raise 扩展方法:

    public static void Raise<TValue>(
        this PropertyChangedEventHandler handler, Expression<Func<TValue>> propertySelector)
    {
        if (handler != null)
        {
            var memberExpression = propertySelector.Body as MemberExpression;
            if (memberExpression != null)
            {
                object sender = ((ConstantExpression)memberExpression.Expression).Value;
                handler(sender, new PropertyChangedEventArgs(memberExpression.Member.Name));
            }
        }
    }

    public static void Raise(this PropertyChangedEventHandler handler, object sender, string propertyName)
    {
        if (handler != null)
        {
                handler(sender, new PropertyChangedEventArgs(propertyName));
        }
    }

再次抱歉，没有具体说明。

Answer 1

这些基本上都是常数，对吧？那么为什么不用它们填充静态字段:

private static readonly TimeSpan RpcTimeOut = TimeSpan.FromSeconds(2);

...
DoWork(RpcTimeOut);

我认为这比尝试归因参数更清晰。

通过将这些设置为静态字段，您实际上不会膨胀任何对象 - 每个 AppDomain 的字段只有一个值。