ZFX + Developia

Code: Alles auswählen

#ifndef PlugIn_h
#define PlugIn_h

#include <windows.h>

namespace Core
{
  class PlugIn
  {
  private:
    PlugIn();

  public:
    template<class T>
    static T* CreateInstance(const char *filename, const char *procname)
    {
      T* pInstance;
      HINSTANCE dll = LoadLibraryA(filename);
      T* (*CreateProc)(void) = (T* (*)(void)) GetProcAddress(dll, procname);

      pInstance = CreateProc();

      //FreeLibrary(dll);
      return pInstance;
    }
 };
}
#endif

Code: Alles auswählen

#ifndef PlugIn_h
#define PlugIn_h

#include <Types.h>
#include <Error.h>
#include <Helper.h>

#include <boost/smart_ptr/shared_ptr.hpp>
#include <windows.h>

#define CHECK_ERROR_WIN32(exp, msg)     if(!(exp)){throw new Core::ExceptionWin32(msg, #exp, __FILE__, __FUNCTION__, __LINE__);};

namespace Core
{
    template<class T>
    class PlugIn
    {
    public:
        PlugIn() : m_hDll(0) {}
        virtual ~PlugIn()
        {
            try
            {
                UnLoad();
            }
            catch(Core::Exception* e)
            {
                     //währe cool hier fehler abfangen zu können
            }
            catch(...)
            {
            }
        }

        void Load(std::wstring libName, std::wstring procName)
        {
            UnLoad();

            CHECK_ERROR_WIN32(m_hDll = LoadLibraryW(libName.c_str()), libName);

            CHECK_ERROR_WIN32(CreateProc = (boost::shared_ptr<T> (API*)(void)) GetProcAddress(m_hDll, UnicodeToAscii(procName).c_str()),
                std::wstring(libName + L"->" + procName));
        }

        void UnLoad()
        {
            if(m_hDll)
            {
                CHECK_ERROR_WIN32(FreeLibrary(m_hDll), L""); //Hier bricht die ausführung ab und windows zeigt eine Fehlermeldung an
                m_hDll = 0;
            }
        }

        boost::shared_ptr<T> CreateInstance()
        {
            return CreateProc();
        }

    protected:
        HINSTANCE m_hDll;
        boost::shared_ptr<T> (*API CreateProc)(void);
    };
}

#endif

Code: Alles auswählen

#include ...
using namespace ...

int main()
{
    try
    {
        PlugIn<IGameShell> shellPlugIn;
        shellPlugIn.Load(L"GameShellWin32.dll", L"CreateGameShell"); //Lädt die Dll

        boost::shared_ptr<IGameShell> shell;
        shell = shellPlugIn.CreateInstance(); //erzeugt das Objekt
        cout<<shell.use_count()<<endl; //giebt 2 zurück da in der Dll auch ein shared_ptr gehalten wird
        //shell.reset(); //falls ich mal nicht das Objekt zerstöre bevorich die Dll frei gebe so stürzt das Programm beim freigeben ab
        shellPlugIn.UnLoad(); //giebt die Dll Frei
    }
    catch(Core::Exception* e)
    {
        wprintf(L"%s\n", e->GetFormatedMessage().c_str());
    }
    catch(...)
    {
        printf("Unknown Exception!\n");
    }

    return 0;
}

Code: Alles auswählen

#include ...
using namespace ...

void Deletor( IGameShell *pGameShell)
{
    cout<<"DoIt"<<endl; //mal zum testen
    delete pGameShell;
}

EXPORT_C shared_ptr<IGameShell> API CreateGameShell()
{
    static shared_ptr<IGameShell> spGameShell(new GameShellWin32(), Deletor); //GameShell soll nen Singleton sein

    return spGameShell;
}

EXPORT_C BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
    switch (fdwReason)
    {
        case DLL_PROCESS_DETACH:
            // detach from process
            try
            {
                shared_ptr<IGameShell> spGameShell = CreateGameShell();
                CHECK_ERROR(!(spGameShell.use_count()>2), IntToUnicode(spGameShell.use_count()));
//wirft eine exception wenn außerhalb der Dll noch shared_ptr auf das Objekt existieren
            }
            catch(Core::Exception* e) //fang ich die Exception hier nicht verschwindet sie irgendwohin wo ich keine ahnung ab
            {
                wprintf(L"%s\n", e->GetFormatedMessage().c_str());
                return FALSE;
            }
            break;
    }
    return TRUE; // succesful
}

Code: Alles auswählen

class CPluginInDLL {
private:
    ::HANDLE MyDLLsHandle;
    PlugIn * ToMyPlugin; // würde ich sogar zu einer Referenz machen, wenn die Factory-Funktion entsprechend aussähe

    static ::HANDLE LoadDLL(wchar_t const * const ItsPath) {
        ::HANDLE Result = ::LoadLibraryW(DLLsPath);
        if(NULL == Result)
            throw "DLL not found";
       return Result;
    }

    static PlugIn * LoadPlugin(::HANDLE const DLLsHandle, char const * const ItsName) {

       PlugIn * (API*)(void) ToFactory = (PlugIn * (*)(void))::GetProcAddress(DLLsHandle, ItsName);
        if(NULL == ToFactory)
            throw "Factory function not found";

        PlugIn * ToPlugin = (*ToFactory)()
        if(nullptr == ToPlugin)
            throw "Plugin fail";

       return ToPlugin;
    }

public:

    CPluginInDLL(wchar_t const * const DLLsPath, char const * const FactorysName)
        : MyDLLsHandle(LoadDLL(DLLsPath))
        , ToMyPlugin(LoadPlugin(MyDLLsHandle, FactorysName))
    { }

    PlugIn * operator -> () { return ToMyPlugin; }
    PlugIn const * operator -> () const { return ToMyPlugin; }

    ~CPluginInDLL() {
        delete *MyPlugin; // Oder alternativ eine Funktion aus der DLL (siehe Schrompf)
        ::FreeLibrary(MyDLLsHandle);
    }

};

Code: Alles auswählen

template<class T>
class PlugIn
{
public:
    typedef shared_ptr<T> (API *Factory)(void);

    static uInt LoadLib(const std::wstring &libName)
    {
        uInt result;
        CHECK_ERROR_WIN32(result = (uInt) ::LoadLibraryW(libName.c_str()), libName);
        return result;
    }

    static Factory LoadFactory(const uInt libHandle, const std::wstring factoryName)
    {
        Factory result;
        CHECK_ERROR_WIN32(result = (Factory) ::GetProcAddress((HINSTANCE) libHandle, UnicodeToAscii(factoryName).c_str()), factoryName);
        return result;
    }

public:
    PlugIn(const std::wstring &libName, const std::wstring &factoryName)
        : m_libName(libName)
        , m_factoryName(factoryName)
        , m_libHandle(LoadLib(m_libName))
        , m_spInstance(LoadFactory(m_libHandle, m_factoryName)())
    {
        CHECK_ERROR(m_spInstance.get(), std::wstring(libName + L"->" + factoryName));
    }

    ~PlugIn()
    {
        m_spInstance.reset();

        if(m_libHandle)
        {
            CHECK_ERROR_WIN32(FreeLibrary((HINSTANCE) m_libHandle), L"");
            m_libHandle = 0;
        }
    }

    T& GetInstance() { return *m_spInstance.get(); }
    const T& GetInstance() const  { return *m_spInstance.get(); }
    T* operator -> ()  { return m_spInstance.get(); }
    const T* operator -> () const { return m_spInstance.get(); }

    PlugIn(const PlugIn& rhs)
        : m_libName(rhs.m_libName)
        , m_factoryName(rhs.m_factoryName)
        , m_libHandle(LoadLib(m_libName))
        , m_spInstance(LoadFactory(m_libHandle, m_factoryName)())
    {
        CHECK_ERROR(m_spInstance.get(), std::wstring(m_libName + L"->" + m_factoryName));
    }

private:
    PlugIn& operator = (const PlugIn&);

protected:
    std::wstring m_libName;
    std::wstring m_factoryName;
    uInt m_libHandle;
    shared_ptr<T> m_spInstance;
};