hosting clr y catching threading exceptions

Question

Estoy tratando de escribir un sistema de complemento que pueda cargar complementos administrados. El host debería poder descargar los complementos si hay alguna excepción. para mi poc Tengo una biblioteca de código de ejemplo en C# que se produce una excepción como esta ...

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; 
    } 

entonces he aplicación de consola Win32 nativa como esto ..

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; 
} 

tema es que si utilizo el código anterior, el host completaría la ejecución del código administrado (la línea "esto nunca debería imprimir" terminaría imprimiendo) Si elimino clrPolicyManager-> SetUnhandledExceptionPolicy (eHostDeterminedPolicy), el proceso de host se bloqueará.

¿Se puede hacer algo en el host no administrado que podría eliminar con gracia la aplicación errante del tiempo de ejecución y continuar funcionando?

Answer 1

Puede iniciar un nuevo dominio de aplicación específicamente para cada plugin dado y lanzarlo dentro. Ver http://msdn.microsoft.com/en-us/library/ms164323.aspx

Cada AppDomain es un entorno aislado donde se puede ejecutar el código. Las excepciones que ocurren en un AppDomain se pueden aislar del resto. Ver: http://msdn.microsoft.com/en-us/library/system.appdomain(v=VS.100).aspx

Answer 2

Parece que la adición siguiente junto con setDefaultAction resuelve el accidente:

clrPolicyManager->SetUnhandledExceptionPolicy(EClrUnhandledException::eHostDeterminedPolicy); 

Answer 3

Has planteado una pregunta muy interesante, gracias por eso.

supongo que este artículo va a ser lo suficientemente útil: http://etutorials.org/Programming/programming+microsoft+visual+c+sharp+2005/Part+III+More+C+Language/Chapter+9+Exception+Handling/Unhandled+Exceptions/

Answer 4

En primer lugar, si se quiere evitar que la aplicación de choque con el código anterior, tendrá que utilizar SetUnhandledExceptionFilter, así:

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

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

Pero esto puede no ser lo que realmente quieres. Una solución (como lo propone Polity, creo) es crear un AppDomain intermediario que pueda detectar fácilmente todas las excepciones no controladas. Usted puede hacer eso en C#, así:

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); 
    } 
} 

Para que esto sea capaz de trabajar sin embargo, que hay que hacer dos cambios en sus clases de plugin:

• deben derivar de MarshalByRefObject
• el método plugin no debe ser estática (métodos estáticos llaman que no pasan por el filtro dominio de aplicación)

por lo que su clase se escribiría así:

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

Si hace esto, puede eliminar las llamadas a SetUnhandledExceptionPolicy, SetActionOnFailure o setDefaultAction, y simplemente reemplazar el código de arranque de esta manera:

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

Si intenta esto con su código de inicio anterior, esta llamada devolverá hr = 0x80131604, que es COR_E_TARGETINVOCATION (TargetInvocationException).