Выкладываю свой класс для критики

CHandle.h

#pragma once
#include "windows.h"
#include "template.h"

class CHandle {
public:
    OPERATORS;
    CHandle():m_handle(NULL){};
    CHandle(HANDLE handle){
        m_handle = handle;
    }
    ~CHandle(){
        Close();
    }
    void Close();
    bool IsValid() const{
        return (( NULL != _m_handle )&&( INVALID_HANDLE_VALUE != _m_handle ));
    };

    bool Attach(HANDLE h);
    HANDLE Detach();

    HANDLE operator =(HANDLE handle){
        Attach(handle);
        return handle;
    }
    bool operator =(const CHandle& handle);

    bool operator!() const{
        return !IsValid();
    };

    operator HANDLE() const{
        return _m_handle;
    };


    static bool Duplicate(
        HANDLE hSourceProcessHandle,
        HANDLE hSourceHandle,
        HANDLE hTargetProcessHandle,
        LPHANDLE lpTargetHandle,
        DWORD dwDesiredAccess,
        BOOL bInheritHandle,
        DWORD dwOptions
        )
    {
        BOOL result = ::DuplicateHandle(hSourceProcessHandle,hSourceHandle,
            hTargetProcessHandle,lpTargetHandle,
            dwDesiredAccess,bInheritHandle,dwOptions
            );
        return ::FromBOOL(result);
    };
    static bool Duplicate(
        HANDLE hSourceProcessHandle,
        HANDLE hSourceHandle,
        HANDLE hTargetProcessHandle,
        LPHANDLE lpTargetHandle,
        BOOL bInheritHandle = false
        )
    {
        return Duplicate(hSourceProcessHandle,hSourceHandle,hTargetProcessHandle,lpTargetHandle,
            DUPLICATE_SAME_ACCESS,bInheritHandle,DUPLICATE_SAME_ACCESS);
    };

    bool Duplicate(HANDLE hTargetProcessHandle,LPHANDLE lpTargetHandle,
        DWORD dwDesiredAccess,bool bInheritHandle,DWORD dwOptions) const;
    bool Duplicate(HANDLE hTargetProcessHandle,LPHANDLE lpTargetHandle,bool bInheritHandle = false) const;
    bool DuplicateFrom(HANDLE hSrcProcess,HANDLE hSrcHandle,
        DWORD dwDesiredAccess = DUPLICATE_SAME_ACCESS,
        bool bInheritHandle = false,
        DWORD dwOptions = DUPLICATE_SAME_ACCESS);

    DWORD Wait(DWORD timeout) const{
        return WaitForSingleObject(_m_handle,timeout);
    }

    DWORD WaitInfinite() const;

    static DWORD WaitForMultipleObjects(IN DWORD nCount,IN CONST CHandle* lpHandles,
        IN BOOL bWaitAll, IN DWORD dwMilliseconds)
    {
        return ::WaitForMultipleObjects(nCount,(HANDLE*)lpHandles,bWaitAll,dwMilliseconds);
    }

    HANDLE Handle(){
        return _m_handle;
    }

    //__declspec(property(get=get_Handle,put=put_Handle)) HANDLE __Handle;
    //HANDLE get_Handle(){
    //    return m_handle;
    //};
    //void put_Handle(HANDLE handle){
    //    Attach(handle);
    //};
private:
    __declspec(property(get=get_m_handle,put=put_m_handle)) HANDLE _m_handle;
    HANDLE get_m_handle() const {
        return m_handle;
    };
    void put_m_handle(HANDLE handle){
#if F_LIB_TEST
        if ( m_handle != handle ){
            dpf(("handle changed: %lx -> %lx",m_handle,handle));
        }
#endif
        m_handle = handle;
    };


    HANDLE m_handle;
};

#include "stdafx.h"
#include "CHandle.h"

void CHandle::Close()
{
    __mytry;
    if ( IsValid() ){
        CloseHandle(_m_handle);
        _m_handle = NULL;
    }
    __myexcept_void;
}

bool CHandle::Attach(HANDLE h)
{
    Close();
    _m_handle = h;
    return IsValid();
}

HANDLE CHandle::Detach(){
    HANDLE h = _m_handle;
    _m_handle = NULL;
    return h;
}

bool CHandle::operator =(const CHandle& handle)
{
    Close();
    handle.Duplicate(GetCurrentProcess(),&m_handle);
    return IsValid();
}

DWORD CHandle::WaitInfinite() const
{
    __mytry;
    return Wait(INFINITE);
    __myexcept(WAIT_FAILED);
}

bool CHandle::Duplicate(HANDLE hTargetProcessHandle,LPHANDLE lpTargetHandle,
                     DWORD dwDesiredAccess,bool bInheritHandle,DWORD dwOptions) const
{
    __mytry;
    BOOL result = Duplicate(GetCurrentProcess(),_m_handle,hTargetProcessHandle,lpTargetHandle,
        dwDesiredAccess,bInheritHandle,dwOptions);
    return FromBOOL(result);
    __myexcept(false);
}

bool CHandle::Duplicate(HANDLE hTargetProcessHandle,LPHANDLE lpTargetHandle,bool bInheritHandle) const
{
    __mytry;
    return Duplicate(hTargetProcessHandle,lpTargetHandle,
        DUPLICATE_SAME_ACCESS,bInheritHandle,DUPLICATE_SAME_ACCESS);
    __myexcept(false);
}

bool CHandle::DuplicateFrom(HANDLE hSrcProcess,HANDLE hSrcHandle,
                   DWORD dwDesiredAccess,bool bInheritHandle,DWORD dwOptions)
{
    __mytry;
    Close();
    return Duplicate(hSrcProcess,hSrcHandle,GetCurrentProcess(),&m_handle,dwDesiredAccess,bInheritHandle,dwOptions);
    __myexcept(false);
};

Какая политика с вашей точки зрения более правильная?

1.
HANDLE hProcess;
CHandle handle = hProcess;
handle = hThread; //генерируется исключение, что бы избегать таких ситуаций. Как бы одна перемення — один ресурс и хранить в ней разные — не красиво как-то

2.
HANDLE hThread;
CHandle h = hProcess;
h = hThread; //h.Close(); h.handle = hThread закрывается текущий хендл и присваевается новое значение

====================================================
CHandle h1,h2;
h1 = h2;

что должно выполняться в этом случае DuplicateHandle или (h1.Close();h1.handle = h2.handle;h2.handle = NULL)????