MyHelper.DoSomething(foo);

foo.DoSomething();

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() );

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

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

using System;
using System.Linq;

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

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;
        }

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);