C#基类非虚方法是否产生虚表开销？无状态实现性能问询

Great question—especially when you're squeezing every ounce of performance out of your C# code! Let's break this down clearly, since your preference for the instance base class (option A) makes total sense for code clarity, and it's important to understand the actual performance implications here.

First: Do non-virtual methods in an instance base class cause vtable overhead? #

Short answer: No, calling non-virtual methods doesn't incur vtable lookup overhead—but there's a small caveat with memory overhead for instances.

Let's unpack that:

• In C#, every reference type implicitly inherits from System.Object, which has virtual methods (ToString(), Equals(), GetHashCode()). That means any instance class (including your base class A) will have a vtable pointer in each instance (8 bytes on 64-bit systems, 4 on 32-bit). This is a fixed memory cost per instance, not a runtime overhead when calling your non-virtual methods.
• When you call a non-virtual method (either defined in A or inherited), the compiler uses static binding. It knows exactly which method to call at compile time, so it skips the vtable lookup entirely. The call is just as direct as calling a static method in option B.

Comparing Option A vs. Option B for Performance #

Let's weigh the two approaches beyond just vtable concerns:

• Option A (Instance Base Class):
  • Pros: Clearer inheritance hierarchy, easier to extend later (if you ever need to add virtual methods for polymorphism, you don't have to rewrite your architecture).
  • Cons: Each instance of B (or A) carries that 8/4 byte vtable pointer. If you're creating thousands or millions of instances, this adds up to measurable memory usage. Also, you have to instantiate B (even if it's stateless) to call the methods, though instantiating a stateless class is extremely cheap.
• Option B (Static Class with Static Methods):
  • Pros: No instance memory overhead at all—you don't create any objects, so no vtable pointers or instance allocations. Static method calls are also statically bound, so same direct call speed as non-virtual instance methods.
  • Cons: No inheritance or polymorphism support. If you need to vary behavior later, you'll have to refactor heavily (e.g., switch to interfaces or delegates). The code relationship is less explicit than inheritance.

Final Recommendation #

If your priority is code clarity and maintainability (and your instance count isn't astronomically high), stick with Option A. The non-virtual method calls won't have vtable lookup overhead, and the small per-instance memory cost is almost certainly worth the cleaner design.

Only if you're dealing with a scenario where every byte of memory counts (like millions of stateless objects) or you absolutely can't afford any instance allocation overhead should you lean toward Option B.

内容的提问来源于stack exchange，提问作者Engineer