时间戳

首页 > 解决方案 > （私有静态引用与私有引用）性能

c# - （私有静态引用与私有引用）性能

问题描述

好的，假设我们有一个生产对象实例的工厂。该工厂生成的实例依赖于一个引用。

我试图了解在对象中将此引用声明为私有或私有静态是否有任何区别。C# 在幕后做什么。以数据存储方式声明引用静态是否更有效。

示例代码：

所以我们在谈论这个

public class ShoesFactory {
    
    public ShoesFactory(Material soleMaterial){ // contractor
       ShoesOfTypeA.SetSoleMaterial(soleMaterial)
    }

    public ShoesOfTypeA GetShoesOfTypeA() {
       return new ShoesOfTypeA ();
    }
}

public class ShoesOfTypeA {
   private static Material soleMaterial;

   public static SetSoleMaterial(soleMaterial){
      ShoesOfTypeA.soleMaterial = soleMaterial;
   }

   
}

对比这个

public class ShoesFactory {
    
    private Material soleMaterial;
    public ShoesFactory(Material soleMaterial){ // contractor
       this.soleMaterial=soleMaterial;
    }

    public ShoesOfTypeA GetShoesOfTypeA() {
       return new ShoesOfTypeA (soleMaterial);
    }
}

public class ShoesOfTypeA {
   private Material soleMaterial;

   public ShoesOfTypeA(soleMaterial) { //constructor
      this.soleMaterial = soleMaterial;
   }
}

编辑：正如 John Alexiou 在评论中所说，在不同类的构造函数上初始化字段违反了封装原则，因此我们将初始化移出承包商

这里的问题不是关于如何遵循 SOLID 设计原则，而是上述代码的性能差异是什么:)

标签： c#performance

解决方案

您的问题不是性能，而是此时的设计。

我建议你有一个Shoe带有指定鞋子类型的属性的类，以及一个生成鞋子的工厂方法。此外，可以使用字段按需读取材料，该Lazy<Material>字段在首次访问时调用某些方法（委托）。

class Program
{
    static void Main(string[] args)
    {
        var factory = new ShoeFactory(ReadMaterial);
        var b = factory.GetShoesOfType(ShoeType.B);
    }
    static Material ReadMaterial()
    {
        return new Material();
    }
}

public class Material
{
}
public enum ShoeType
{
    A,
    B,
    C
}

public sealed class Shoe
{
    public Shoe(Material material, ShoeType type)
    {
        Material=material;
        Type=type;
    }

    public Material Material { get; }
    public ShoeType Type { get; }
}

public class ShoeFactory
{
    private readonly Lazy<Material> soleMaterial;

    public ShoeFactory(Func<Material> materialFactory)
    {
        this.soleMaterial=new Lazy<Material>(materialFactory);
    }

    public Shoe GetShoesOfType(ShoeType type)
    {
        return new Shoe(soleMaterial.Value, type);
    }
}

上面的设计是直接的、灵活的，如果你要问我关于性能的问题，就像任何其他现代应用程序一样，最慢的部分是初始化类，并且通过保持类结构简单，你可以帮助编译器自行进行适当的优化。

推荐阅读