Overloading Property Setters

Question

I was looking at this question, and it made me wonder.

Whenever I define a class with auto properties,

// Example A
public class MyObject
{
  public int MyInt { get; set; }
}

the JIT compiler will convert it to similar to this:

// Example B
public class MyObject
{
  private int _MyInt;

  public int get_MyInt()
  { 
    return _MyInt;
  }

  public void set_MyInt(int value)
  {
    _MyInt = value;
  }
}

So you could hypothetically write something like the following:

// Example C.1
public class MyObject 
{
  public int MyInt { get; set; }

  public void set_MyInt(string value)
  {
    MyInt = int.Parse(value);
  }
}

Or something potentially like this:

// Example C.2
public class MyObject 
{
  private int _myInt;
  public int MyInt 
  {
    get { return _myInt; }
    set 
    { 
      _myInt = value; 
    }
    set(string) 
    { 
      _myInt = int.Parse(value); 
    }
  }
}

And have this functionality exist without compiler errors.

// Example D
public void DoSomething(string someIntegerAsAString)
{
  var myObject = new MyObject()
  {
    MyInt = someIntegerAsAString
  };
}

What's stopping the compiler from saying code such as Example D, where the desired result is inferred and it works correctly and expected? The functionality is there, shown in Example B.

Is this something that's against how the language designers have designed the language to work and behave?

Nothing is stopping you in the first example. Compilation errors are stopping you in the second. Overloaded property setters are not supported. You might as well just use a method. There's probably some exotic ways to abuse it as well so why waste time, effort and money on something very rarely used? — Jeroen Vannevel
– Jeroen Vannevel, Commented Apr 6, 2015 at 23:32
In fact you can do method overload with dynamic bindings hanselman.com/blog/…, not possible with auto-IMPLEMENTED property but it can help sometimes — Random
– Random, Commented Apr 7, 2015 at 4:35

Andre Pena · Accepted Answer · 2015-04-06 23:39:26Z

2

You can, indeed, do this...

public class MyObject 
{
  public int MyInt { get; set; }

  public void set_MyInt(string value)
  {
    MyInt = int.Parse(value);
  }
}

...inspite of the obvious performance overhead of converting a string to an int.

This will not work:

public class MyObject 
{
  private int _myInt;
  public int MyInt 
  {
    get { return _myInt; }
    set 
    { 
      _myInt = value; 
    }
    set(string) 
    { 
      _myInt = int.Parse(value); 
    }
  }
}

...because C# doesn't support setter overload. However, you could achieve something kind of similar with implicit type conversion, but it has to be implemented on your own types. Integer is a value type so it's inherently sealed.

answered Apr 6, 2015 at 23:39

Andre Pena

59.7k53 gold badges213 silver badges257 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Cameron Over a year ago

I realize this. But the key that I'm talking about is that the compiler recognizing this functionality. I guess I'm wanting more information (at a high level) of why the compiler doesn't support something like this where, from my perspective, the basic framework for the functionality exists.

stakx - no longer contributing Over a year ago

@Cameron: I realise I am very late to the party, but as a regular reader of Eric Lippert's blog (who used to work on the C# compiler) I think the likeliest explanation why the C# compiler does not allow overloaded setters is this: It simply wasn't perceived as a useful or important enough language feature. As Eric always pointed out, implementing a feature has a cost, so unless a feature isn't wanted badly enough, it won't be there.

Paulo Morgado · Accepted Answer · 2015-04-10 08:25:52Z

It's not the JIT that generates the get_* and set_* methods for the properties.

If you decompile this code:

public int MyInt { get; set; }

you'll get this IL:

.property instance int32 MyInt()
{
    .get instance int32 C::get_MyInt()
    .set instance void C::set_MyInt(int32)
} // end of property C::MyInt

.method public hidebysig specialname instance int32 
        get_MyInt() cil managed
{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
    // Code size       11 (0xb)
    .maxstack  1
    .locals init (int32 V_0)
    IL_0000:  ldarg.0
    IL_0001:  ldfld      int32 C::'<MyInt>k__BackingField'
    IL_0006:  stloc.0
    IL_0007:  br.s       IL_0009
    IL_0009:  ldloc.0
    IL_000a:  ret
} // end of method C::get_MyInt

.method public hidebysig specialname instance void 
        set_MyInt(int32 'value') cil managed
{
    .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor() = ( 01 00 00 00 ) 
    // Code size       8 (0x8)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  ldarg.1
    IL_0002:  stfld      int32 C::'<MyInt>k__BackingField'
    IL_0007:  ret
} // end of method C::set_MyInt

If you look at PropertyInfo, you'll see that it has a GetMethod and a SetMethod. "Method", not "Methods".

This is tied to the framework, although I don't know any language where a property has more than one getter or setter. Do you know any such language?

LinqPad shows a simplified view of IL. I think the output of ildasm would be more helpful here.
Because it would show the .property and that you set the getter and setter there.
@svick D is such a language. A setter there is a method with one parameter. As with methods, you can have multiple with different types.
Since they are just methods than it's probably not terribly difficult to overload them if the .net team decided that was important to put on the roadmap.

Andre Pena · Accepted Answer · 2015-04-07 00:15:22Z

The C# designers did give us the ability to implement implicit type conversion. However, they probably didn't want that to work with the primitive types to avoid confusion.

Imagine this lines:

var myvar = 2;
myvar = "4";

Anyone looking at the above lines would think we're talking about a dynamic language like JavaScript. In JavaScript, myvar would be a string from the second line on. If C# supported what you described, it would still be an int. I, for one, would find it confusing.

Collectives™ on Stack Overflow

Overloading Property Setters

3 Answers 3

2 Comments

4 Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

4 Comments

Comments

Linked

Related