Перегружатели недвижимости

Question

Я смотрел на this question, и это заставило меня задуматься.

Всякий раз, когда я определить класс с авто свойствами,

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

ЛТ-компилятор преобразует его в похожее на это:

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

    public int get_MyInt() 
    { 
    return _MyInt; 
    } 

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

Таким образом, вы могли бы гипотетически написать что-то вроде следующего:

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

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

Возможно, что-то такое:

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

И эта функциональность существует без ошибок компилятора.

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

Что останавливает компилятор от высказывания код, такой как примере D, где желаемый результат выведенного и он работает правильно и ожидалось? Функциональность там, указанная в Пример B.

Это что-то противоречит тому, как языковые дизайнеры разработали язык для работы и поведения?

Answer 1

Вы можете, конечно, сделать это ...

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

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

... несмотря на очевидную производительность накладных расходов преобразования строки в междунар.

Это не будет работать:

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

... потому, что C# не поддерживает setter перегрузки. Тем не менее, вы можете достичь чего-то подобного с implicit type conversion, но он должен быть реализован на ваших собственных типах. Integer - это тип значения, поэтому он по сути запечатан.

Answer 2

Дизайнеры C# дали нам возможность реализовать неявное преобразование типа. Однако они, вероятно, не хотели, чтобы это работало с примитивными типами, чтобы избежать путаницы.

Представьте эти строки:

var myvar = 2; 
myvar = "4"; 

Каждый ищет в строках выше будет думать, что мы говорим о динамическом языке, как JavaScript. В JavaScript myvar будет строкой из второй строки. Если C# поддерживает то, что вы описали, оно все равно будет int. Я, например, сочтет это запутанным.

Answer 3

Это не JIT, который генерирует методы get_* и set_*.

Если вы декомпилировать этот код:

public int MyInt { get; set; } 

вы получите этот 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 

Если вы посмотрите на PropertyInfo, вы увидите, что она имеет GetMethod и SetMethod. «Метод», а не «Методы».

Это связано с каркасом, хотя я не знаю ни одного языка, на котором свойство имеет более одного геттера или сеттера. Вы знаете какой-либо такой язык?