C# 如何配置类的空可移动组件（对象字段）？

假设我们有一个包含一些组件（对象字段）的类，其中一些组件可以为null（删除） 是否适合创建没有（组件）字段的新类，或者使用接口来处理它。假设我们有几个可以为某些对象删除的组件 提前Thx

public class Class1{
   Component1 component1;
   Component2 component2;
   Component3 component3;//can be null (removed)
   Component4 component4;//can be null (removed)
}
public class Class2{//removed component3,component4(new class)
   Component1 component1;
   Component2 component2;      
}
public class Class3{//removed component3(new class)
   Component1 component1;
   Component2 component2;  
   Component4 component4;  
}
public class Class4{//removed component4(new class)
   Component1 component1;
   Component2 component2;      
   Component3 component3;      
}

或使用接口

public interface IComponent1{

}
public class Component1:IComponent1{

}
public class NoComponent1:IComponent1{

}
public interface IComponent2{

}
public class Component2:IComponent2{

}
public class NoComponent2:IComponent2{

}
public interface IComponent3{

}
public class Component3:IComponent3{

}
public class NoComponent3:IComponent3{

}
public interface IComponent4{

}
public class Component4:IComponent4{

}
public class NoComponent4:IComponent4{

}
public class Class1{
    IComponent1 componentBehaviour1;
    IComponent2 componentBehaviour2;
    IComponent3 componentBehaviour3;
    IComponent4 componentBehaviour4;
}

---

或者在类的方法中检查空条件（如果需要）。

根据我的经验，最好遵循面向对象的原则。在您的情况下，我认为您应该首先为所有必填字段创建一个类：

    public class Class1{
   Component1 component1; 
   Component2 component2;
   }

然后为每个可为空的字段使用接口，如：

 public Interface interface1{
       Component1 component3; 
       }

然后是另一个界面，如：

public Interface interface2{
           Component1 component4; 
           }

那么在你的课堂上你可以：

public class Class2: Class1, interface1

还有其他课程，如：

    public class Class2: Class1, interface2
    public class Class3: Class1, interface1, interface2

---

听起来可能很傻，但为什么不让一个类公开一组组件呢？ 大概是这样的：

public interface IComponent{}

public class Foo{
    private readonly IList<IComponent> _components;

    public void AddComponent(IComponent component){
        // do your magic here
    }

    public IEnumerable<T> GetComponents<T>() where T : IComponent {
        // do your magic here
    }
}

公共接口IComponent{}
公开课Foo{
专用只读IList_组件；
公共无效添加组件（IComponent组件）{
//在这里施展你的魔法
}
public IEnumerable GetComponents（），其中T:IComponent{
//在这里施展你的魔法
}
}

您的问题主要基于观点，因此不适合堆栈溢出。这就是说，我的观点是，如果字段对于一组特定的对象总是不使用，那么是的……将类划分为单独的类是非常合适的，并且字段适合于每个单独类的实例。另一方面，如果出现这样一种情况，您必须将一个类的一个实例替换为另一个类的一个实例，因为您最初有一个

null

值，但现在不再有，反之亦然，那么不…不要这样做。谢谢你，但是如果我有几个类有一些相同的字段，我怎样才能访问不同类的对象字段（例如在循环中）。我应该为这些具有泛型的类实现GetComponent（）“我有几个具有相同字段的类”——为什么要这样做？如果它们是相同的字段，则将它们设置为相同的类。如果由于某种原因，它们不能是同一个类，那么考虑定义每个类都可以实现的接口，那么当需要这些字段时，可以使用接口。这是一个组件，可以是也可以不是。基于组件的设计模式假设我们有一个类具有可显示字段（Displayable Displayable），而一个类没有。我想实现基于组件的类而不是继承。组件字段进入接口？！您只能在接口中使用接口方法和getter setter。您可以在接口中使用组件的接口，类似于

IComponent