WH> Хоть бы 3 минуты подумал почему это сделано. См ниже.

class MyClass : IActivatable
{
    // ...
}

class MyClass : IActivatable, ISavable
{
    // ...
}

class MyClass : IActivatable, ISavable, IEditable
{
    int    ID          { get; }
    string Description { get; set; }
}

[Transaction(Required)]
void Save()
{
    // ...
}

[LogException]
[Transaction(Required)]
void Save()
{
    // ...
}

[LogException]
[Transaction(Required)]
void Save([NotNull] object p)
{
    // ...
}

[LogException]
[ExcludeFromLog(typeof(NullParameterException))]
[Transaction(Required)]
void Save([NotNull] object p)
{
    // ...
}

[DataAccess]
class MyCustomerDataAccess
{
    void InsertCustomer (int ID, string Name);
    void UpdateCustomer (int ID, string Name);
    void GetCustomerByID(int ID);
}

[DataAccess]
class MyCustomerDataAccess
{
    void InsertCustomer (int ID, string Name);
    void UpdateCustomer (int ID, [Nullable] string Name);
    void GetCustomerByID(int ID);
}

[BusinessLayer]
class MyCustomerManager
{
    [Validate]
    void InsertCustomer(Customer c)
    {
        // ...
    }
        
    [Validate]
    void UpdateCustomer(Customer c)
    {
        // ...
    }

    void GetCustomerByID(int ID)
    {
        // ...
    }
}

IT>>Ровно столько на сколько у него хватит энтузизизма

MessageQueue source( "server\\sourceQueue" );

using( MessageQueue source = new MessageQueue( "server\\sourceQueue" ) )

ref class some_class
{
    MessageQueue source;
    some(String^ path)
        :source(path)
    {}
};

class some_class
    :IDisposable
{
    MessageQueue source;
    some(String path)
    {
        source=new MessageQueue(path);
    }
    void Dispose()
    {
        source->Dispose();
    }
};

Semantically, a C++ program can create object of any type T in any storage location:
    On the native heap:    T* t1 = new T;
        As usual, pointers (*) are stable, even during GC
        As usual, failure to explicitly call delete will leak
    On the gc heap:        T^ t2 = gcnew T;
        Handles (^) are object references (to whole objects)
        Calling delete is optional: "Destroy now, or finalize later."

Native pointers (*) and handles (^):
^ is like *, except ^ points to a whole object on the gc heap, 
can’t be ordered, and can’t be cast to void* (or integral type) and back. (There is no void^.)

Boxing is implicit and strongly typed:
    int^ i = 42;    // strongly typed boxed value
    Object^ o = i;    // usual derived-to-base conversions ok

Unboxing is explicit:
Dereferencing a V^ indicates the value inside the box, and this syntax is also used for unboxing:
    int k = *i;    // unboxing to take a copy
    int% i2 = *i;    // refer into the box (no copy)
    swap( *i, k );    // swap contents of box with stack variable
                // (no copy, modifies the contents of box)

int* i;
int j[40]={};
if(rand()%2)
{
    i=j;
}
else
{
    i=<какимто образом создаем в ГЦ хипе>int(243);
}
...i+12...

IT>Ровно столько на сколько у него хватит энтузизизма

IT>Всего один? Слабак!

#if   defined(__MY_COOL_COMPILER)
#define mixin __declspec(built_in) struct 
#elif defined(__HIS_COOL_COMPILER)
#define mixin __built_in struct 
#else
#define mixin struct 
#endif

#define mixin_impl()\
self_type* self()\
{\
    return static_cast<self_type*>(this);\
}\
const self_type* self()const\
{\
    return static_cast<const self_type*>(this);\
}\
//end mixin_impl

template<class self_type>
mixin IActivatableImpl
    :IActivatable
{
    mixin_impl()
};

template<class self_type>
mixin ISavableImpl
    :ISavable
{
    mixin_impl()
};

struct MyClass
    :IActivatableImpl<MyClass>
    ,ISavableImpl<MyClass>
{
};

template<class T>
struct Validator
{
    Validator(T* _this)
        :this_(_this)
    {
        save_state();
    }
    ~Validator()
    {
        if(забыл как зовут функцию сгнализирующею об исключении||!is_valid())
        {
            rollback();
        }
    }
private:
    T* this_;
    //...
};
Validator<T> Validate(T* _this)
{
    return Validator<T>(_this);//RVO Optimization
}
...
    void InsertCustomer(Customer c)
    {
        auto Validate(this);
                //...
    }

IT>Ко всему прочему, Александреску учил тебя правильному использованию комбинации наследования и шаблонов. В результате, некоторые на форуме (одного я точно знаю ) говорят, что ты можешь творить с этим чудеса. А теперь представь, что у тебя появилось ещё одно измерение — вся информация о типах и полный контроль над генерацией кода. Сумеешь этим распорядиться?

IT>Видишь ли в чём дело. Первый персональный компьютер был сделан умельцами в гараже. VB писался на коленках двумя студентами в самолёте. Кто знает, кем и где будет написан язык программирования намбер ван начинающегося столетия

void Transfer() 
{
    MessageQueue    source( "server\\sourceQueue" );
    String^ qname = (String^)source.Receive().Body;
    MessageQueue    dest1( "server\\" + qname ),
                      dest2( "backup\\" + qname );
    Message^ message = source.Receive();
    dest1.Send( message );
    dest2.Send( message );
}

void Transfer() 
{  
    using( MessageQueue source = new MessageQueue( "server\\sourceQueue" ) ) 
    {
        String qname = (String)source.Receive().Body;
        using( MessageQueue    dest1 = new MessageQueue( "server\\" + qname ),
                                dest2 = new MessageQueue( "backup\\" + qname ) ) 
        {
            Message message = source.Receive();
            dest1.Send( message );
            dest2.Send( message );
        }
    }
}

void Transfer() 
{
    MessageQueue    source = null, 
                    dest1 = null, 
                    dest2 = null;
    try 
    {
        source = new MessageQueue( "server\\sourceQueue" );
        String qname = (String)source.Receive().Body;
        dest1 = new MessageQueue( "server\\" + qname );
        dest2 = new MessageQueue( "backup\\" + qname );
        Message message = source.Receive();
        dest1.Send( message );
        dest2.Send( message );
    }
    finally 
    {
        if( dest2 != null ) 
        { 
            dest2.Dispose(); 
        }
        if( dest1 != null ) 
        { 
            dest1.Dispose(); 
        }
        if( source != null ) 
        { 
            source.Dispose(); 
        }
    }
}

    template<class T>
    ref class ARefTemplate { /*…*/ };    // ok

WH>#if   defined(__MY_COOL_COMPILER)
WH>#define mixin __declspec(built_in) struct 
WH>#elif defined(__HIS_COOL_COMPILER)
WH>#define mixin __built_in struct 
...
WH>

WH>Круто

[return: NotNull]
object Test()
{
  ...
     // Здесь будет ошибка при компиляции или в рантайме если 
     // при компиляции невозможно определить что возвратит функция.
  return null;
}

VD>Тебе самому это не страшно читать?

class MyClass 
    :IEditable
    ,ISuperEditable
{
    int    ID          { get; }
    string Description { get; set; }
}

STDMETHODIMP CSRCOMM_OPCGroup::SetDatatypes
(/* [in] */                        DWORD dwCount
,/* [size_is][in] */            OPCHANDLE *phServer
,/* [size_is][in] */            VARTYPE *pRequestedDatatypes
,/* [size_is][size_is][out] */    HRESULT **ppErrors
)
try
{
    scoped_lock(this);//Декларируем что данный метод надо синхронизировать
    
    com_check        (owner_, E_FAIL);//Декларируем проверки
    com_check_arg    (dwCount>0);//Эта кидает E_INVALIDARG
    com_check_ptr    (phServer);//Эти E_POINTER
    com_check_ptr    (pRequestedDatatypes);
    com_check_ptr    (ppErrors);

    com_auto_arr<HRESULT>    hr(dwCount);//Елси память не выделена то вылетит E_OUTOFMEMORY
    HRESULT res=S_OK;//Дальше чистая логика
    for(DWORD i=0;i<dwCount;++i)
    {
        if(ref_t<CSRCOMM_OPCGroupItem> item=get_item(phServer[i]))
        {
            if(FAILED(item->set_type(pRequestedDatatypes[i])))
                hr[i]=OPC_E_BADTYPE;
            else
                hr[i]=S_OK;
        }
        else
            hr[i]=OPC_E_INVALIDHANDLE;
        if(FAILED(hr[i]))
            res=S_FALSE;
    }
    //До этой строчки код полностью exception safe
    //А дальше им просто взяться не откуда
    *ppErrors    =hr.detach();
    return res;
}
com_catch_all()//Тут ловим исключения _com_error, достаем из него HRESULT и возвращаем

Тут надо понимать одну вещь. Человеческий мозг -- гораздо более мощное орудие, чем любой компилятор. Поэтому попытка избавиться от необходимости думать, спихивая свою работу тупой машине, контрпродуктивна.

using System;

namespace VirtualTest
{
    public interface IDo
    {
        void Do();
    }

    public class Do: IDo
    {
        #region IDo Members
        void IDo.Do()
        {
            Console.WriteLine();
        }
        #endregion
    }
    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        [STAThread]
        static void Main(string[] args)
        {
            IDo @do = new Do();
            @do.Do();
        }
    }
}

            @do.Do();
00000023  mov         ecx,edi 
00000025  mov         eax,dword ptr [ecx] 
00000027  mov         eax,dword ptr [eax+0Ch] 
0000002a  mov         eax,dword ptr [eax+00000094h] 
00000030  call        dword ptr [eax]

// This is the main project file for VC++ application project 
// generated using an Application Wizard.

#include "stdafx.h"

#using <mscorlib.dll>

using namespace System;

public __gc __interface IDo
{
    void Do();
};

public __gc class DoClass: public IDo
{
public:
    void Do()
    {
        Console::WriteLine();
    }
};

int _tmain()
{
    IDo* _do = new DoClass();
    _do->Do();
    return 0;
}

    _do->Do();
00000020  mov         ecx,edi 
00000022  mov         eax,dword ptr [ecx] 
00000024  mov         eax,dword ptr [eax+0Ch] 
00000027  mov         eax,dword ptr [eax+00000094h] 
0000002d  call        dword ptr [eax]

namespace System {
    // IDisposable is an attempt at helping to solve problems with deterministic
    // finalization.  The GC of course doesn't leave any way to deterministically
    // know when a finalizer will run.  This forces classes that hold onto OS
    // resources or some sort of important state (such as a FileStream or a 
    // network connection) to provide a Close or Dispose method so users can 
    // run clean up code deterministically.  We have formalized this into an 
    // interface with one method.  Classes may privately implement IDisposable and
    // provide a Close method instead, if that name is by far the expected name
    // for objects in that domain (ie, you don't Dispose of a FileStream, you Close
    // it).
    //
    // This interface could be theoretically used as a marker by a compiler to 
    // ensure a disposable object has been cleaned up along all code paths if it's 
    // been allocated in that method, though in practice any compiler that 
    // draconian may tick off any number of people.  Perhaps an external tool (like
    // like Purify or BoundsChecker) could do this.  Instead, C# has added a using 
    // clause, which will generate a try/finally statement where the resource 
    // passed into the using clause will always have it's Dispose method called.  
    // Syntax is using(FileStream fs = ...) { .. };
    //
    // Dispose should meet the following conditions:
    // 1) Be safely callable multiple times
    // 2) Release any resources associated with the instance
    // 3) Call the base class's Dispose method, if necessary
    // 4) Suppress finalization of this class to help the GC by reducing the
    //    number of objects on the finalization queue.
    // 5) Dispose shouldn't generally throw exceptions, except for very serious 
    //    errors that are particularly unexpected. (ie, OutOfMemoryException)  
    //    Ideally, nothing should go wrong with your object by calling Dispose.
    //
    // If possible, a class should define a finalizer that calls Dispose.
    // However, in many situations, this is impractical.  For instance, take the
    // classic example of a Stream and a StreamWriter (which has an internal 
    // buffer of data to write to the Stream).  If both objects are collected 
    // before Close or Dispose has been called on either, then the GC may run the
    // finalizer for the Stream first, before the StreamWriter.  At that point, any
    // data buffered by the StreamWriter cannot be written to the Stream.  In this
    // case, it doesn't make much sense to provide a finalizer on the StreamWriter
    // since you cannot solve this problem correctly.  
    /// <include file='doc\IDisposable.uex' path='docs/doc[@for="IDisposable"]/*' />
    public interface IDisposable {
        /// <include file='doc\IDisposable.uex' path='docs/doc[@for="IDisposable.Dispose"]/*' />
        void Dispose();
    }
}

M>Как ты думаешь, если я перед завершением using FileStream дискетку из дисковода вытащу. Будет исключение