ГВ>Ну, Игорь, это уже отдаёт пионерством: "эта дорога неверна, мы срочно побежим другой". А чтобы не было каши надо чаще думать, чем работать. Помогает, проверено.

int Sum(int a, int b)
{
    return a + b;
}

HRESULT SomeClass::getSomeValue(LONG *retVal, LONG a, LONG b)
{
    COM_CALL_TRACE_TMDEF(TraceMode<Logged>, SomeClass, getSomeValue)

    *retVal = a + b;

    return S_OK;
}

А если без ёрничанья, то перспектива получения каши если не из БЛ+вспомогатльный код, то уж внутри вспомогательного кода или внутри самой БЛ — по любому остаётся.

using System;
using System.Runtime.Remoting.Proxies;

[AttributeUsage(AttributeTargets.Class)]
public class MyClassFactoryAttribute : ProxyAttribute
{
    public override MarshalByRefObject CreateInstance(Type type)
    {
        return base.CreateInstance(typeof(MyRealClass));
    }
}

[MyClassFactory]
public class MyClass : ContextBoundObject
{
}

class MyRealClass : MyClass
{
}

class Test
{
    static void Main()
    {
        MyClass mc = new MyClass();

        Console.WriteLine(mc.GetType().Name);
    }
}

V>Тема крайне интересная, и хотелось бы от IT услышать хоть один достойный пример, где АОП имело бы преимущество перед ООП. Хуки не предлагать , в реальных системах хуки делаются путем хаков (Win32). Интересно услышать задачу, относящуюся к целевым бизнес-объектам, а не к вспомогательным/системным вещам. (системного рода задачки на С++ весьма весело решаются, и никто не придерживается строгого ООП, если речь идет о чем-то весьма системном, типа представлении стека как списка параметров, в одной из своих библиотек на С++ я именно так и делал и даже больше, ибо возможность произвольной реинтерпретации произвольного участка памяти в С++ есть, хоть это и опускает нас на уровень древнего С... кстати, многое из Remouting в .Net именно на таком уровне и сделано, весьма это далеко от АОП и ООП)

V>Если не трудно, развития ради, интересно посмотреть на код и оценить трудоемкость подхода IT в решении его собственной задачки. ГВ предложил одну строчку кода на все интересующие методы, трудоемкость в этом случае ясна и понятна. IT, давай решение на АОЯП — справедливости ради, а то пока не ясно как все это сравнивать

IT>Кстати. О фабриках и синглетонах в .NET. AOP в действии

........

IT>class Test
IT>{
IT>    static void Main()
IT>    {
IT>        MyClass mc = new MyClass();

IT>        Console.WriteLine(mc.GetType().Name);
IT>    }
IT>}
IT>

Console.WriteLine(System.Runtime.Remoting.RemotingServices.IsTransparentProxy(mc));

IT>Правда появляются другие проблемы

IT>using System;
IT>using System.Runtime.Remoting.Proxies;

IT>[AttributeUsage(AttributeTargets.Class)]
IT>public class MyClassFactoryAttribute : ProxyAttribute
IT>{
IT>    public override MarshalByRefObject CreateInstance(Type type)
IT>    {
IT>        return base.CreateInstance(typeof(MyRealClass));
IT>    }
IT>}

IT>[MyClassFactory]
IT>public class MyClass : ContextBoundObject
IT>{
IT>}

IT>class MyRealClass : MyClass
IT>{
IT>}

IT>class Test
IT>{
IT>    static void Main()
IT>    {
IT>        MyClass mc = new MyClass();

IT>        Console.WriteLine(mc.GetType().Name);
IT>    }
IT>}
IT>

struct MyClassBase
{

};

typedef    MyClassBase    MyClass;

int main(...)
{
    MyClass* mc= new MyClass();
}

template<typename Base>
struct    MyRealClass: public    Base
{

};

typedef    MyRealClass<MyClassBase>    MyClass;

int main(...)
{
    MyClass* mc= new MyClass();
}

template<typename Base>
struct    MyRealClassWithAdittionalStrategy : public Base
{

};

typedef    MyRealClassWithAdditionalStrategy<MyRealClass<MyClassBase> >     MyClass;

int main(...)
{
    MyClass* mc= new MyClass();
}

M>> В С++ нет ТР. Это ведь не значит, что там не может быть АОП.

M>>идет перпендикулярно.

механика проксей предназначена не для перехвата вызовов, а для работы ремоутинга.

Именно для перехвата вызовов она и предназначена.

AVK>Блин, Мика, почитай что такое ExecuteMessage и что он делает

M>>Сужаем круг требований. Так глядишь дойдем до того, что это можно было бы предвидеть на этапе проектирования

CrossContextChannel.SyncProcessMessage(message)
{
  Identity serverIdentity = InternalSink.GetServerIdentity(message);
  Context context = serverIdentity.ServerContext;

  ContextTransitionFrame frame = new ContextTransitionFrame();

  Thread.CurrentThread.EnterContext(сontext, ref frame);
  сontext.GetServerContextChain().SyncProcessMessage(message);
  Thread.CurrentThread.ReturnToContext(ref frame);
}

M>>Думаю, вот для этого

M>>CrossContextChannel.SyncProcessMessage(message)
M>>{
M>>  Identity serverIdentity = InternalSink.GetServerIdentity(message);
M>>  Context context = serverIdentity.ServerContext;

M>>  ContextTransitionFrame frame = new ContextTransitionFrame();

M>>  Thread.CurrentThread.EnterContext(сontext, ref frame);
AVK>M>  сontext.GetServerContextChain().SyncProcessMessage(message);
M>>  Thread.CurrentThread.ReturnToContext(ref frame);
M>>}
M>>

Context.GetServerContextChain()
{
  return new ServerContextTerminatorSink();
}

ServerContextTerminatorSink.SyncProcessMessage(message)
{
  IMessageSink sink = InternalSink.GetServerIdentity(message).GetServerObjectChain(out obj);
  return sink.SyncProcessMessage(message);
}

ServerIdentity.GetServerObjectChain()
{
  IMessageSink sink = new ServerObjectTerminatorSink(serverObj);
}

ServerObjectTerminatorSink.SyncProcessMessage
{
      IMessage iMessage2;

      IMessage iMessage1 = InternalSink.ValidateMessage(msg);
      if (iMessage1 != null)
      {
        return iMessage1;
      }
      IMethodCallMessage iMethodCallMessage = msg is IMethodCallMessage;
      LogicalCallContext logicalCallContext1 = null;
      bool flag = false;
      try
      {
        object local1 = _server;
        VerifyIsOkToCallMethod(local1, iMethodCallMessage);
        LogicalCallContext logicalCallContext2 = null;
        if (iMethodCallMessage != null)
        {
          logicalCallContext2 = iMethodCallMessage.LogicalCallContext;
        }
        else
        {
          logicalCallContext2 = (LogicalCallContext)msg.Properties["__CallContext"];
        }
        logicalCallContext1 = CallContext.SetLogicalCallContext(logicalCallContext2);
        flag = true;
        logicalCallContext2.PropagateIncomingHeadersToCallContext(msg);
        PreserveThreadPrincipalIfNecessary(logicalCallContext2, logicalCallContext1);
        if (IsOKToStackBlt(iMethodCallMessage, local1) && ((Message)iMethodCallMessage).Dispatch(local1, fExecuteInContext))
        {
          iMessage2 = new StackBasedReturnMessage();
          ((StackBasedReturnMessage)iMessage2).InitFields((Message)iMethodCallMessage);
          LogicalCallContext logicalCallContext3 = CallContext.GetLogicalCallContext();
          logicalCallContext3.PropagateOutgoingHeadersToMessage(iMessage2);
          ((StackBasedReturnMessage)iMessage2).SetLogicalCallContext(logicalCallContext3);
        }
        else
        {
          MethodBase methodBase = GetMethodBase(iMethodCallMessage);
          object[] locals1 = null;
          object local2 = null;
          RemotingMethodCachedData remotingMethodCachedData = InternalRemotingServices.GetReflectionCachedData(methodBase);
          object[] locals2 = Message.CoerceArgs(iMethodCallMessage, remotingMethodCachedData.Parameters);
          local2 = PrivateProcessMessage(methodBase, locals2, local1, methodPtr, fExecuteInContext, out locals1);
          CopyNonByrefOutArgsFromOriginalArgs(remotingMethodCachedData, locals2, ref locals1);
          LogicalCallContext logicalCallContext4 = CallContext.GetLogicalCallContext();
          iMessage2 = new ReturnMessage(local2, locals1, (locals1 != null) ? (int)locals1.Length : 0, logicalCallContext4, iMethodCallMessage);
          logicalCallContext4.PropagateOutgoingHeadersToMessage(iMessage2);
        }
        CallContext.SetLogicalCallContext(logicalCallContext1);
      }
      catch (Exception e)
      {
        iMessage2 = new ReturnMessage(e, iMethodCallMessage);
        ((ReturnMessage)iMessage2).SetLogicalCallContext(iMethodCallMessage.LogicalCallContext);
        if (flag)
        {
          CallContext.SetLogicalCallContext(logicalCallContext1);
        }
      }
      return iMessage2;
}