C# （专用静态引用与专用引用）性能

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

我试图理解在对象中将此引用声明为private或private static是否有任何区别。C#在幕后的所作所为。以数据存储方式声明引用静态是否更有效

示例代码：

所以我们正在讨论这个问题

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

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

对这个

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

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

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

这里的问题不是如何遵循实体设计原则，而是

---

以上代码的性能差异是什么：）

您的问题不在于性能，而在于设计

我建议您使用一个

Shoe

类，该类具有指定鞋子类型的属性，并使用一个工厂方法来生成鞋子。此外，还可以使用

Lazy

字段按需读取材料，该字段在首次访问材料时调用某些方法（委托）

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);
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var工厂=新鞋厂（ReadMaterial）；
var b=factory.GetShoesOfType（ShoeType.b）；
}
静态材质ReadMaterial（）
{
退回新物料（）；
}
}
公开课材料
{
}
公共枚举类型
{
A.
B
C
}
公共密封类鞋
{
公共鞋（材质、鞋底类型）
{
材料=材料；
类型=类型；
}
公共材料{get；}
公共ShoeType类型{get；}
}
公共类鞋厂
{
私人只读资料；
公共鞋厂（职能材料厂）
{
this.soleMatterial=新的惰性（materialFactory）；
}
公共鞋GetShoesOfType（鞋型）
{
返回新鞋（鞋底材料、值、类型）；
}
}

---

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

你不能运行性能分析器吗（例如，或与比较您的conde代码段？请编写有效的

C

代码。

private static SoleMeterial

无效，因为它缺少类型。我不认为性能是主要问题。静态与否有更重要的后果这两个代码段都很糟糕，因为您在另一个类。这违反了封装的原则。另外，如果您想要延迟初始化，请查看类型的

Lazy

。谢谢@UweKeim。我一定会对此进行研究

public class ShoesOfTypeA {
   private Material soleMaterial;

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

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);
    }
}