Hosting Clr i wychwytywanie wyjątków gwintowania

Question

Próbuję napisać system wtyczek, który może załadować zarządzane wtyczki. Host powinien mieć możliwość zwolnienia wtyczek, jeśli istnieją wyjątki. dla mojego PKOl mam bibliotekę przykładowy kod w C#, który zgłasza wyjątek jak to ...

public static int StartUp(string arguments) 
{ 
     Console.WriteLine("Started exception thrower with args {0}", arguments); 
     Thread workerThread = new Thread(() => 
      { 
       Console.WriteLine("Starting a thread, doing some important work"); 
       Thread.Sleep(1000); 
       throw new ApplicationException(); 
      } 
     ); 
     workerThread.Start(); 
     workerThread.Join(); 
     Console.WriteLine("this should never print"); 
     return 11; 
    } 

potem mam natywną aplikację konsoli win32 tak ..

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    ICLRMetaHost *pMetaHost  = NULL; 
    HRESULT hr; 
    ICLRRuntimeInfo *runtimeInfo = NULL;  
    __try 
    { 
     hr = CLRCreateInstance(CLSID_CLRMetaHost, IID_ICLRMetaHost, (LPVOID*)&pMetaHost); 
     hr = pMetaHost->GetRuntime(L"v4.0.30319",IID_ICLRRuntimeInfo,(LPVOID*)&runtimeInfo); 
     ICLRRuntimeHost *runtimeHost = NULL; 
     hr = runtimeInfo->GetInterface(CLSID_CLRRuntimeHost,IID_ICLRRuntimeHost, (LPVOID*)&runtimeHost);  
     ICLRControl* clrControl = NULL; 
     hr = runtimeHost->GetCLRControl(&clrControl); 
     ICLRPolicyManager *clrPolicyManager = NULL; 
     clrControl->GetCLRManager(IID_ICLRPolicyManager, (LPVOID*)&clrPolicyManager); 
     clrPolicyManager->SetDefaultAction(OPR_ThreadAbort,eUnloadAppDomain); 
     hr = runtimeHost->Start(); 
     DWORD returnVal = NULL;   
     hr = runtimeHost->ExecuteInDefaultAppDomain(L"ExceptionThrower.dll",L"ExceptionThrower.MainExceptionThrower",L"StartUp",L"test",&returnVal);   
     runtimeHost->Release(); 
    } 
    __except(1) 
    { 
     wprintf(L"\n Error thrown %d",e); 
    } 
    return 0; 
} 

Problem jest, że jeśli Używam powyższego kodu, host zakończyłby uruchamianie zarządzanego kodu (linia "to nigdy nie powinno drukować" zakończyłoby drukowanie) Jeśli usunę clrPolicyManager-> SetUnhandledExceptionPolicy (eHostDeterminedPolicy), to proces hosta ulegnie awarii.

Czy można zrobić cokolwiek w niezarządzanym hoście, który mógłby z wdziękiem usunąć błędną aplikację z środowiska wykonawczego i kontynuować pracę?

Answer 1

można rozpocząć nową AppDomain specjalnie dla każdej danej wtyczki i uruchomić go w środku. Zobacz http://msdn.microsoft.com/en-us/library/ms164323.aspx

Każda AppDomain to izolowane środowisko, w którym można uruchomić kod. Wyjątki występujące w jednym AppDomain mogą być izolowane od reszty. Zobacz: http://msdn.microsoft.com/en-us/library/system.appdomain(v=VS.100).aspx

Answer 2

Wygląda na to, dodając następujący wraz z setDefaultAction postanawia katastrofę:

clrPolicyManager->SetUnhandledExceptionPolicy(EClrUnhandledException::eHostDeterminedPolicy); 

Answer 3

Podniosłeś bardzo interesujące pytanie, dzięki za to.

Przypuszczam, ten artykuł będzie na tyle pomocne: http://etutorials.org/Programming/programming+microsoft+visual+c+sharp+2005/Part+III+More+C+Language/Chapter+9+Exception+Handling/Unhandled+Exceptions/

Answer 4

Przede wszystkim, jeśli chcesz, aby zapobiec awarii aplikacji z powyższym kodzie, musisz użyć SetUnhandledExceptionFilter, tak:

LONG WINAPI MyUnhandledExceptionFilter(struct _EXCEPTION_POINTERS *exceptionInfo) 
{ 
    // do something useful 
    return EXCEPTION_EXECUTE_HANDLER; // prevent crash 
} 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    SetUnhandledExceptionFilter(MyUnhandledExceptionFilter); 
     ... 
} 

Ale to może nie być to, czego naprawdę chcesz. Jednym z rozwiązań (zgodnie z propozycją Polity I) jest stworzenie pośrednika AppDomain, który może łatwo wychwycić wszystkie nieobsługiwane wyjątki. Można to zrobić w C# tak:

public class PluginVerifier 
{ 
    public static int CheckPlugin(string arguments) 
    { 
     AppDomain appDomain = AppDomain.CreateDomain(Guid.NewGuid().ToString()); 
     appDomain.UnhandledException += AppDomainUnhandledException; 
     object obj = appDomain.CreateInstanceAndUnwrap("ExceptionThrower", "ExceptionThrower.MainExceptionThrower"); 
     object ret = obj.GetType().InvokeMember("Startup", BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod, null, obj, new object[] { arguments }); 
     AppDomain.Unload(appDomain); 
     return (int)ret; 
    } 

    private static void AppDomainUnhandledException(object sender, UnhandledExceptionEventArgs e) 
    { 
     AppDomain appDomain = (AppDomain)sender; 
     // the following will prevent "this should never print" to happen 
     AppDomain.Unload(appDomain); 
    } 
} 

Do tego, aby móc pracować jednak trzeba zrobić dwie zmiany do swoich klas wtyczki:

• muszą one pochodzić z MarshalByRefObject
• metoda plugin nie muszą być statyczne (metody statyczne nazwać nie przechodzą przez filtr AppDomain)

Więc twoja klasa będzie napisane tak:

public class MainExceptionThrower: MarshalByRefObject 
{ 
    public int StartUp(string arguments) 
    { 
    ... 
    } 
} 

Jeśli to zrobisz, możesz usunąć wywołań SetUnhandledExceptionPolicy, SetActionOnFailure lub setDefaultAction, i po prostu zastąpić kod bootstrap takiego:

hr = runtimeHost->ExecuteInDefaultAppDomain(L"PluginSystem.dll", L"PluginSystem.PluginVerifier", L"CheckPlugin", L"test", &returnVal);   

Jeśli spróbujesz to z kodu startowego powyżej, to wywołanie zwróci hr = 0x80131604, czyli COR_E_TARGETINVOCATION (TargetInvocationException).