In IL, return type is a valid manner of determining an overload, no such
functionality exists in C#(or VB or C++ to my knowledge, Eiffel supports
this I believe. I've been trying to figure out a simple way to add it to C#
as well). As such it is possible in IL to generate multiple properties with
the same name, but C# probably will not deal with it well(have you tested
it?).

It is also impossible to have a property with several set methods because
the CLI spec has a restriction that only one getter and one setter can exist
on a given method.

From the ECMA CLI spec:

.get specifies the getter for this property. The <typeSpec> defaults to the
current type. Only one getter may be
specified for a property. To be CLS compliant, the definition of getter
shall be marked specialname.

.set specifies the setter for this property. The <typeSpec> defaults to the
current type. Only one setter may be
specified for a property. To be CLS compliant, the definition of setter
shall be marked specialname.

.other is used to specify any other methods that this property comprises.

As for AddOtherMethod, it will add a method marked by .other. These methods
could be used by another language and associated with a property, but C# and
VB will see them as normal methods. If you were to create a language that
does what you want(allows multiple set methods), you could use
AddOtherMethod or .other in il to add the setters, although only your
language would allow you to use them like properties, other languagues would
have to call the methods explicitly.

A possible method(in IL) would be:

   .property specialname string TestProperty()
   {
.set instance void set_TestProperty(class [mscorlib]System.String)
.get instance string get_TestProperty()
.other instance void SetTestPropertyAsInt32(class [mscorlib]System.Int32)

.other instance void SetTestPropertyAsDecimal(class
[mscorlib]System.Decimal)

   }

associated with attributes could allow your C# variant, for example, to hide
SetTestPropertyAsInt32() and SetTestPropertyAsDecimal() as a property while
exposing the methods as normal methods for other languages.

However, that is a theoretical situation and impossible in standard C#.

As an offside, it would be an interesting addition, something I may play
with. Although doing it directly using set {} and get{} would be annoying,
writing seperate methods with the proper signature and associating them with
properties could be valuable, maybe(Syntax made up on the spot, method
bodies declared outside the proprty because propertys are annoying enough to
parse):

public string MyProperty
{
 get
 {
  return 1;
 }
 set
 {
  str = value;
 }
 set void SetMyPropertyAsInt32(int);
 set void SetMyPropertyAsDecimal(Decimal);
}
public void SetMyPropertyAsInt32(int x)
{

}
public void SetMyPropertyAsDecimal(Decimal x)
{
}