ВВ>MyHelper.DoSomething(foo);
ВВ>

ВВ>foo.DoSomething();
ВВ>

using System;
using System.Linq;

class C
{
  Func<int> f = "".Count;
}

YNT>Можно пример( допустим, на некоем псевдокоде) работы описанного вами механизма? Или это утверждение что-то вроде "хорошо бы чтобы был мир во всем Мире"

interface IVehile
{
   void Move();
}
interface IGun
{
   void Fire();
}

class Car : IVehile
{
  public void Move()
  {
    //some implementation
  }
  
  public void OtherMethod(){}
  public void AndOneMoreNotIntrestingMethod(){}
}

class Gun : IGun
{
  public void Fire()
  {
     //some implementation
  }
}

public class Tank: IVehile, IGun
{
   [TakeMethod( Move )]
     private Car _chassis;  //теперь у класса Tank есть собственный метод Move, взятый из класса Car. Можно вызывать tank.Move();
     
     [TakeMethod( Fire )]
     private Gun _gun;       //теперь у класса Tank есть собственный метод Fire, взятый из класса Gun. Можно вызывать tank.Fire();
     
     //но можно комбинировать и не напряму, а как в обычной агрегации
     public void LocateAndDestroy()
     {
            //IsTargetLocated & SearchTarget - реализованы тоже в этом классе каким-то там способом,
            // включая возможное собственное внутреннее состояние
            while( !IsTargetLocated )  
            {
                _chassis.Move();
                SearchTarget();
            }
            _gun.Fire();
     }
}

//никто однако не мешает сделать то же и без агрегирования любого из имеющихся объектов
public class LaserTank: IVehile, IGun
{
    [TakeMethod( Move )]
      private Car _chassis;
      
      public void Fire()
      {
         //Implement Laser Fire
      }
}

//или можно использовать метод не целиком как есть а как часть (аналог вызова base.Method):
public class RoadBuildingTank: IVehile, IGun
{
     private Car _chassis;  
     
     [TakeMethod( Fire )]
     private Gun _gun;      
     
     public void Move()
     {
        BuildRoadAtFront();
        _chassis.Move();
        DestroyRoadAtBehind();
     }
}


//одно из очевидных применений передавать объекты-агрегаты как параметры.
//В результате получим динамически создаваемые классы

class Tank : IVehile, IGun
{
   [TakeMethod( Move )]
     private ICar _chassis;  
     
     [TakeMethod( Fire )]
     private IGun _gun;
     
     public Tank( IVehile chassis, IGun gun )
     {
      _chassis = chassis;
      _gun = gun;
     }
}

//использование
var tank = new Tank( new TracksVehile(), new Gun() );
tank.Move();
tank.Fire();
var laserTank = new Tank( new TracksVehile(), new Laser() );
laserTank.Move();
laserTank.Fire();

var infantrySupport = new Tank( new Car(), new MachineGun() );

YNT>Можно пример( допустим, на некоем псевдокоде) работы описанного вами механизма? Или это утверждение что-то вроде "хорошо бы чтобы был мир во всем Мире"

interface IInterface1
{
  void F1();
}

interface IInterface2
{
  void F2();
  void F3();
}

class A : IInterface1
{
  ...
}

class B : IInterface2
{
  ...
}

class C : IInterface1, IInterface2
{
  // Делегирование интерфейсов.
  IInterface1 = _a;
  IInterface2 = _b;

  // Явная реализация метода, перекрывает делегирование этого метода, описанное выше.
  void IInterface2.F3()
  {  
  }

  // Объявление композитов, которым будет произведено делегирование.
  private A _a = new A();
  private B _b = new B();
}

MyHelper.DoSomething(foo);

foo.DoSomething();

public static int MyCount<TSource>(IEnumerable<TSource> source)
{
    var is2 = source as ICollection<TSource>;
    
    if (is2 != null)
        return is2.Count;
    
    var num = 0;

    foreach (var c in source)
        num++;

    return num;
}

var f = new Func<IEnumerable<Char>,Int32>(MyCount);

class A { virtual void DoSomething(){}}

class B:A { 
    override void DoSomething(){ 
        DoAdditionalStuff();
        base.DoSomething();
    }
}

interface IA
{
    void DoSomething();
}

class A : IA
{ 
    void DoSomething(){}
}

class B : IA
{ 
    override void DoSomething()
    { 
        DoAdditionalStuff();
        _a.DoSomething();
    }
    private A _a = new A();
}

public class MyBusinessClass : MyBusinessClassBase, INotifyPropertyChanged 
{
  ...
}

public class MyNotifyPropertyChanged : INotifyPropertyChanged
{
  public event PropertyChangedEventHandler PropertyChanged = () => { };
  
  public void SendPropertyChanged(...)
  {
    ...
  }
}

0>>Естественно, придется делегировать. Я в изначальном посте указал, что для того, о чем я говорю, требуется определенная поддержка со стороны ЯП, иначе придется прописывать все делегации руками. Я не предлагаю свою идею, как стиль программирования на C#

interface IA
{
    void DoSomething();
}

class A : IA
{ 
    void DoSomething(){}
}

class B : IA
{ 
    public B (IA a)
    {
        _a = a;
    }

    override void DoSomething()
    { 
        DoAdditionalStuff();
        _a.DoSomething();
    }

    private IA _a;
}

public static int Count<TSource>(this IEnumerable<TSource> source)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    ICollection<TSource> is2 = source as ICollection<TSource>;
    if (is2 != null)
    {
        return is2.Count;
    }
    int num = 0;
    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            num++;
        }
    }
    return num;
}

ВВ>>Где здесь магия? Все то же самое можно представить в виде обычного метода.

public static Func<Int32> Count<TSource>(this IEnumerable<TSource> source)
        {
            Func<Int32> f = () => {
                    if (source == null)
                    {
                        //throw Error.ArgumentNull("source");
                    }
                    ICollection<TSource> is2 = source as ICollection<TSource>;
                    if (is2 != null)
                    {
                        return is2.Count;
                    }
                    int num = 0;
                    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
                    {
                        while (enumerator.MoveNext())
                        {
                            num++;
                        }
                    }
                    return num;
                };
            return f;
        }

N>using System;
N>using System.Linq;

N>class C
N>{
N>  Func<int> f = "".Count;
N>}
N>

def f : Func[int] = "a".Count;
WriteLine(f());
_ = ReadLine();

def f = "a".Count;
WriteLine(f());
_ = ReadLine();

VD>>Блин, а зачем ты тогда меня для Немерла это заставил сделать? Я то думал, так в шарпе можно. Часа 3 убил на реализацию .

def f = () => MyCount("");

The delegate type and the method must have compatible return types. That is, the return type of method must be assignable to the return type of type.

If firstArgument is supplied, it is passed to method every time the delegate is invoked; firstArgument is said to be bound to the delegate, and the delegate is said to be closed over its first argument. If method is static (Shared in Visual Basic), the argument list supplied when invoking the delegate includes all parameters except the first; if method is an instance method, then firstArgument is passed to the hidden instance parameter (represented by this in C#, or by Me in Visual Basic).

If firstArgument is supplied, the first parameter of method must be a reference type, and firstArgument must be compatible with that type.

type
  IMyInterface = interface
    procedure Method1;
  end;

  TMyImpl = class (TInterfacedObject, IMyInterface)
    procedure Method1;
  end;

  TMyClass = class(TObject, IMyInterface)
    FMyInterface: IMyInterface;
    property MyInterface: IMyInterface read FMyInterface
      implements IMyInterface;
  end;

procedure TMyImpl.Method1;
begin
  ShowMessage('TMyImpl.Method1');
end;

procedure foo;
var
  MyClass: TMyClass;
  MyInterface: IMyInterface;
begin
  MyClass := TMyClass.Create;
  MyClass.FMyInterface := TMyImpl.Create;
  MyInterface := MyClass;
  MyInterface.Method1;
end;

using System;

namespace ConsoleApplication3
{

    class StaticFunctions
    {
        private static readonly char[] s_defSplits = { ' ', '\t', '\n' };

        public static string[] Split(string str)
        {
            return str.Split(s_defSplits, StringSplitOptions.RemoveEmptyEntries);
        }

        public static string[] SplitCustom(char[] split, string str)
        {
            return str.Split(split, StringSplitOptions.RemoveEmptyEntries);
        }
    }



    class Program
    {

        public static Func<T2, TResult> Bind1st<T1, T2, TResult>(Func<T1, T2, TResult> func, object arg)
        {
            return (Func<T2, TResult>)Delegate.CreateDelegate(typeof(Func<T2, TResult>), arg, func.Method);
        }

        static void Main(string[] args)
        {
            Func<string, string[]> defSplit = StaticFunctions.Split;
            Func<string, string[]> customSplit = Bind1st(
                new Func<char[], string, string[]>(StaticFunctions.SplitCustom), new[] { '|' });

            Console.WriteLine(string.Join("-", defSplit("a b c")));
            Console.WriteLine(string.Join("-", customSplit("a|b|c")));
        }
    }
}

YNT>>Можно пример( допустим, на некоем псевдокоде) работы описанного вами механизма? Или это утверждение что-то вроде "хорошо бы чтобы был мир во всем Мире"

interface IInterface1
{
  void F1();
}

interface IInterface2
{
  void F2();
  void F3();
}


mixin template A()
{
    void F1()
    {
    }
}


mixin template B()
{
    void F2()
    {
        
    }
    
    void F3()
    {
        
    }
    
}

class C : IInterface1, IInterface2
{
    mixin A!();
    mixin B!();
    
    void F3()
    {
        
    }
}

type
  IMyInterface = interface
    procedure P1;
    procedure P2;
  end;

  TMyImplClass = class (TInterfacedObject, IMyInterface)
    procedure P1;
    procedure P2;
  end;

  TMyClass = class(TObject, IMyInterface)
    FMyImplClass: TMyImplClass;
    property MyImplClass: TMyImplClass read FMyImplClass
      implements IMyInterface;
    procedure IMyInterface.P1 = MyP1;
    procedure MyP1;
  end;

  procedure TMyImplClass.P1;
  begin
    ShowMessage('TMyImplClass.P1');
  end;

  procedure TMyImplClass.P2;
  begin
    ShowMessage('TMyImplClass.P2');
  end;

  procedure TMyClass.MyP1;
  begin
    ShowMessage('TMyClass.MyP1');
  end;

procedure foo;
var
  MyClass: TMyClass;
  MyInterface: IMyInterface;
begin
  MyClass := TMyClass.Create;
  MyClass.FMyImplClass := TMyImplClass.Create;
  MyInterface := MyClass;
  MyInterface.P1;    // calls TMyClass.MyP1;
  MyInterface.P2;    // calls TImplClass.P2;
end;

IInterface1 = _a;

IInterface1 = ref _a;

interface IInterface1
{
  void F1();
}

interface IInterface2
{
  void F2();
  void F3();
}

class A // необязательно : IInterface1
{}

class B // пусть проверяется во время инстанциирования : IInterface2
        // аналогично с добавлением обычных интерфейсов к классу-наследнику без добавления методов
{}

class C : IInterface1|A, IInterface2|B
{
  // Явная реализация метода, перекрывает делегирование этого метода, описанное выше.
  void IInterface2.F3()
  {  }

  // Неявная, наверно, тоже :)
  public void F2()
  {}
  
  // доступ к миксинам-кирпичикам, конструктор
  public C(int arg1, string arg2) 
    : this.A(arg1), this.B(arg2) 
  {}

  // доступ к миксинам-кирпичикам, тела методов
  public double Prop {
    get { return A.Prop * 0.1; }
    set { A.Prop = value / 0.1; }
  }
}