GZ>И это плохо, что нельзя.

PropRef<int> pr = new PropRef<int>(p1.get_P1, p1.set_P1);

Error 1 'ConsoleApplication1.Probe1.P1.get': cannot explicitly call operator or accessor

GZ>И это плохо, что нельзя.

Delegate deleg=(SingleDelegate)MyClass.MyMethod;

int MyClass.Multiply(int x, int y){return x*y;}
Delegate Twice=(SingleDelegate)MyClass.MyMethod(2, Value.Unknown);

Twice(2);

V>PropRef<int> pr = new PropRef<int>(p1.get_P1, p1.set_P1);
V>

V>Блин, нельзя обратиться напрямую к акцессорам!

using System;

class PropertyHolder<T>
{
    private delegate T Getter();
    private delegate void Setter(T value);

    public PropertyHolder(object obj, string propertyName)
    {
        try
        {
            _getter = (Getter)Delegate.CreateDelegate(
                typeof(Getter), obj, "get_" + propertyName);
        }
        catch (ArgumentException ex)
        {
            throw new ArgumentException(
                "Неудается подключить PropertyHolder к getter-у свойства "
                + propertyName, "propertyName", ex);
        }

        try
        {
            _setter = (Setter)Delegate.CreateDelegate(
                typeof(Setter), obj, "set_" + propertyName);
        }
        catch (ArgumentException ex)
        {
            throw new ArgumentException(
                "Неудается подключить PropertyHolder к setter-у свойства "
                + propertyName, "propertyName", ex);
        }
    }

    private Getter _getter;
    private Setter _setter;

    public T Property
    {
        get { return _getter(); }
        set { _setter(value); }
    }
}

class A
{
    private int myVar = 10;

    public int MyProperty
    {
        get { return myVar; }
        set { myVar = value; }
    }
}

class Program
{
    static void Main()
    {
        PropertyHolder<int> holder1 = new PropertyHolder<int>(new A(), "MyProperty");

        Console.WriteLine(holder1.Property);
        holder1.Property++;
        Console.WriteLine(holder1.Property);
    }
}

// тип-хелпер функционального объекта
public class Func1<RET, P1> {

    // интерфейс вызова функционального объекта
    public interface Delegate {
        public RET invoke(P1 param1);
    }

    public static Delegate Create(object target, IntPtr method) {}
    public static Delegate Create(object target, MethodInfo methodInfo) {}
    public static Delegate Create(Type type, MethodInfo methodInfo) {}
    public static Delegate Create(object target, string methodName) {}
    public static Delegate Create(Type type, string methodName) {}
    public static Delegate Create(System.Delegate delegate) {}
}


public class SqrFunc : Func1<double, double>.Delegate {
    public double Invoke(double d) { return d*d; }
}

public class SqrStaticFunc {
    public static double Invoke(double d) { return d*d; }
}

public delegate double Func1D(double p1);

void Main() {
    Func1<double, double> func = new SqrFunc();
    double d1 = func.Invoke(10);
    func = Func1<double, double>.Create(SqrStaticFunc.Invoke); // typeof(SqrStaticFunc), "Invoke"
    d1 = func.Invoke(10);
    func = Func1<double, double>.Create(new Func1D(SqrStaticFunc.Invoke));
    d1 = func.Invoke(10);
}

int value = propRef;

int value = propRef.Property;

struct VarRef__
{
    void *varptr;
};
struct PropRef__
{
    void *getter;
    void *setter;
};

union RefStruct
{
    bool      isVarRef;
    VarRef__  vref;
    PropRef__ pref;
};

Mab>Тот факт, что компилятор скрывает от нас его, еще не делает метод необычным Скажем, если объявить на MC++ свойство с параметрами, то из С# его можно (и нужно) будет вызывать через set_XXX.

public class C1
{
  private int _i;
  public int I1
    {
      get { return GetI(); }
        set    { SetI(value);    }
    }
    
    public int GetI() { return _i; }
    
    public void SetI(int value) 
    { 
        if (_i % 2 == 0) 
            _i = value; 
        else 
            throw new ArgumentException("value must be an odd number", "value"); 
    }
    public int I2;
}

public class C2
{
  public delegate void SetInt(int value);
    public delefate int GetInt(int value);
  public static void Test1(ref int value)
    {
      value++;
      value++;
    }
    public static void Test2(GetInt in, SetInt out)
    {
      out(in()+1);
      out(in()+1);
    }
}

С1 с1 = new C1();
С2.Test1(ref c1.I2);
C2.Test2(new C2.GetInt(c1.GetI), new C2.SetInt(c1.SetI));

С1 с1 = new C1();
С2.Test1(ref c1.I2);
C2.Test2(c1.GetI, c1.SetI);

С1 с1 = new C1();
С2.Test1(ref c1.I2);
C2.Test2(c1.I1, с1.I1);

public class C3
{
  public C2.SetInt I { get { return SetK; } }
    public void SetK(int k) { Console.Write(k);}
}

...
C3 c3 = new C3();
C2.Test2(c3.I, null); // что мы имели здесь в виду? Вычисляем c3.I или кастим один из его методов к делегату?

StringBuilder sb = new StringBuilder();
...
if(sb.Length > 0) 
    sb.Length--; // фактически, я делаю sb.Length = sb.Length - 1;

int i = 0;
i--;

// варнинг! Компилируется только под C#8.0!
C1 c1 = new C1();
C2.Test1(ref c1.I);
// компилятор строит следующий код позади сцены:
int temp$$_882133 = c1.I;
C2.Test1(ref temp$$_882133);
c1.I = temp$$_882133;

1.1.4 stable rev. 510

class A
{
    public int Var;
    public int Prop { get { return x + y;  } 
                      set { x = value - y; } }

    private int x;
    private int y;
};

class B
{
    public void P(ref int i)
    {
        int j = i; // Читаем.
        i = j * 2; // Пишем.
    }
    public void M()
    {
        A a = new A();
        
        P(ref A.Var);
        P(ref A.Prop);
    }
}

GZ>Вобщем штука примерно получится такая. У нас есть некоторый тип делегат который может ссылаться на несколько методов. Хороший или он плохой — вопрос второй. Делегат сущность типизированная. Вместо типизированного метода, типизируем проперть.(ну информация о типе будет типа есть setter/getter, какой тип). Желательно чтобы компилятор C# делал это сам, как и статическую проверку при использовании. На входе в JIT у нас будет переменная и ее тип(а может так-же как и в делегате объект). Его задача — просто подставить вызов сеттера или геттера. Вот и все.

void P(ref int i)
{
    i = 7; // ???
}

PropertyRef myProperty=new PropertyRef<int>(a.Prop);
int func(PropertyRef<int> myProp)
{
Prop=10;
}

S>Хотя vref нам нужен только для оптимизации производительности, поскольку pref будет работать медленнее. Но, в принципе, реализуемо, чтобы переменные можно было передавать и через pref (посредством фиктивного делегата). Таким образом получим vref только для переменных, зато быстро, а pref — для обоих случаев, пусть не так быстро, зато универсально. Вот .

void v(pref int a)
{
  v1(a);//и что здесь компилировать? Вызов проперти или передачу значения?
}
void v1(int a){};

менеджед MSIL, нет понятия памяти. Ссылка — это понятие компиляторов.

В терминах процессора, нет понятия ссылки и типа. В менеджед MSIL, нет понятия памяти.

The ldfld instruction pushes onto the stack the value of a field of obj.

The newobj instruction creates a new object or a new instance of a value type...
...After the constructor has been called, the now initialized object reference is pushed on the stack.

1.1.4 stable rev. 510