3

Suppose we had a generated class with a lot of redundant accessors. They are just accessors, they are not fields. They are not called anywhere. They just sit there being redundant and ugly.

For example:

public class ContrivedExample
{
    public int ThisOneIsUsed { get; set; }

    public int ThisOneIsNeverCalled0 { get { /* Large amounts of logic go here, but is never called. */ } }
    public int ThisOneIsNeverCalled1 { get { /* Large amounts of logic go here, but is never called. */ } }
    public int ThisOneIsNeverCalled2 { get { /* Large amounts of logic go here, but is never called. */ } }
    //...
    public int ThisOneIsNeverCalled99 { get { /* Large amounts of logic go here, but is never called.*/ } }
}

ContrivedExample c = new ContrivedExample() { ThisOneIsUsed = 5; }

The only overhead I can think of is that it would make the .DLL larger. I expect that there would be zero runtime penalties.

Does this cause any other overhead? Even a tiny overhead of any kind?

Steve Wortham
  • 21,740
  • 5
  • 68
  • 90
Buh Buh
  • 7,443
  • 1
  • 34
  • 61
  • How about simply deleting code that is not used? Why keep it around at all? – Ed S. May 09 '12 at 17:03
  • possible duplicate of [Performance overhead for properties in .NET](http://stackoverflow.com/questions/3264833/performance-overhead-for-properties-in-net) – Alain May 09 '12 at 17:03
  • @Ed I could delete it. The trouble is, it is generated so will be likely to come back soon. Also, I don't have the patience to read though each one and decide which are needed and which not. Also, it would ruin my ContrivedExample. ;-) – Buh Buh May 09 '12 at 17:57
  • Well... change the generator logic then? If it is too much work to justify then you'll be fine, those properties aren't causing you any trouble. – Ed S. May 09 '12 at 18:06

1 Answers1

7

It is unlikely to have any measurable run-time overhead. In any case since it is performance question - measure your usage and make decisions for your case if in doubt.

Unreferenced methods do not get compiled by JIT nor cause direct run-time overhead.

Metadata for the class will be bigger (along with size of assembly as you've mentioned).

You may get indirect impact if the class is used in some code that involves a lot of reflection, also if code repeatedly reflects over the same class it is likely wrong by itself.

Alexei Levenkov
  • 98,904
  • 14
  • 127
  • 179