static <ClassName>.<Method/Property/... Name> : <Type> { ... }

public static MyClass.ExtensionMethod(p1 : Param1, p2 : Param2) : int { this.DoSomething(); }

public static MyClass.ExtensionProperty : int { get { this.X } set { this.X = value } }

public static MyClass.ExtensionEvent : MyEevnt { ... }

   public static PropertyName[this x : Type1] : Type2
   {
      ...
   }

_NN>>Насколько сложно сделать ?

VD>Попробуй — узнаешь .

public static X : int {this m : MyClass} { get { m.Y + 1 } set { m.Y = value - 1 } }

public static MyClass.X : int { get { this.Y + 1 } set { this.Y = value - 1 } }

[ExtensionPropertyAttribute(Type = Getter)]
public static get_X(m : MyClass) : int { m.Y + 1 }

[ExtensionPropertyAttribute(Type = Setter)]
public static set_X(m : MyClass, value : int) : void { m.Y = value - 1 }

_NN>>Насколько сложно сделать ?

def tm = 20.Minutes;

namespace X
{                    
    [assembly: Nemerle.Internal.OperatorAttribute ("X", "Minutes", true, 283, 284)]

    macro @Minutes(val)
    {
        <[ System.TimeSpan(0, $val, 0); ]>
    }
}

def tm = 20 Minutes;

_NN>public static X : int {this m : MyClass} { get { m.Y + 1 } set { m.Y = value - 1 } }
_NN>

_NN>public static MyClass.X : int { get { this.Y + 1 } set { this.Y = value - 1 } }
_NN>

public static X(this m : MyClass) : int { get { m.Y + 1 } set { m.Y = value - 1 } }
// или
public static X : int
{
  this m : MyClass;
  get { m.Y + 1 }
  set { m.Y = value - 1 }
}

VD>public static X(this m : MyClass) : int { get { m.Y + 1 } set { m.Y = value - 1 } }
VD>// или
VD>public static X : int
VD>{
VD>  this m : MyClass;
VD>  get { m.Y + 1 }
VD>  set { m.Y = value - 1 }
VD>}
VD>

    public static X[this m : MyClass] : int 
    { 
        get { m.Y + 1 } 
        set { m.Y = value - 1 } 
    }

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

get_PropertName(this obj : Type1) : Type2
{
  ...
}

set_PropertName(this obj : Type1, value : Type2)
{
  ...
}

public static extension X : int (this m : MyClass) { get { m.Y + 1 } set { m.Y = value - 1 } }

// без событий-расширений
SomeSingletonList.Add(x);
SomeSingletonList.Event += myHandler;

// с ними
x.Event += myHandler;

C>   public static PropertyName[this x : Type1] : Type2
C>   {
C>      ...
C>   }
C>

public static PropertyName[this x : Type1] [index : int] : Type2 { .. }

_NN>public static PropertyName[this x : Type1] [index : int] : Type2 { .. }
_NN>

public static PropertyName[this x : Type1, index : int] : Type2 { .. }

// это  AttachedPropery  чтобы присвоить соответственно надо вызвать SetDrag
        public static readonly DependencyProperty TypeProperty = DependencyProperty.RegisterAttached("Type",
                                                                                           typeof(Type),
                                                                                           typeof(DependencyObject),
                           new PropertyMetadata((d, e) => SetTypes(d, new Type[] { (Type)e.NewValue })));

        public static void SetType(DependencyObject d, Type v)
        {
            d.SetValue(TypeProperty, v);
        }

        public static Type GetType(DependencyObject d)
        {
            return (Type)d.GetValue(TypeProperty);
        }
//А это соответсвенно аналогичный ивент
        public static readonly RoutedEvent DropEvent = EventManager.RegisterRoutedEvent("Drop", RoutingStrategy.Bubble,
                                                                                        typeof(Action<UIElement, DropEventArgs>),
                                                                                        typeof(DependencyObject));

        public static void AddDropHandler(UIElement source, Action<UIElement, DropEventArgs> handler)
        {
            source.AddHandler(DropEvent, handler);
        }

        public static void RemoveDropHandler(UIElement source, Action<UIElement, DropEventArgs> handler)
        {
            source.RemoveHandler(DropEvent, handler);
        }

    <ListView x:FieldModifier="public" AllowDrop="True"
              GUICommon:DDC.Type="{x:Type SUFMonitoringClasses:TemplateFunction}"
              GUICommon:DDC.Drop="OnDrop"
              SelectionMode="Single" Name="listBoxDalls" VerticalAlignment="Stretch">

obj..Prop = value; // устанавливаем свойство
obj ++= handler;   // цепляем событие

obj..Prop = value; // устанавливаем свойство
obj..Event += handler;   // цепляем событие

obj.Prop from AttachedPropertyClass = 10;
obj.Event from AttachedPropertyClass += value;

class C
{
    // метод-член без параметров
    public Foo() : ReturnType { ... }

    // метод-расширение без параметров
    static Foo(this self : C) : ReturnType { ... }

    // метод-член с одним параметром
    public Foo(parm : Type1) : ReturnType { ... }
   
    // метод-расширение с одним параметром
    static Foo(this self : C, parm : Type1) : ReturnType { ... }

    
    // свойство-член
    public Foo : ReturnType { ... }

    // свойство-расширение
    public Foo[this self : C] : ReturnType { ... }

    // свойство-член с одним параметром (индексер)
    public Foo[parm : Type1] : ReturnType { ... }

    // свойство-ресширение с одним параметром (индексер)
    public Foo[this self : C, parm : Type1] : ReturnType { ... }
}

C>    // свойство-расширение
C>    public Foo[this self : C] : ReturnType { ... }

C>    // свойство-член с одним параметром (индексер)
C>    public Foo[parm : Type1] : ReturnType { ... }

C>    // свойство-ресширение с одним параметром (индексер)
C>    public Foo[this self : C, parm : Type1] : ReturnType { ... }
C>}

get_PropName(this arg : Type1) : Type2
{
  ...
}

set_PropName(this arg : Type1, value : Type2) : void
{
  ...
}

VD>get_PropName(this arg : Type1) : Type2 {}
VD>set_PropName(this arg : Type1, value : Type2) : void {}
VD>

get_PropName(this arg : Type1, index : int, ...)                : Type2 {}
set_PropName(this arg : Type1, index : int, ..., value : Type2) : void {}