_set_se_translator

Articolo
03/26/2013

Le eccezioni Win32 (eccezioni strutturate C#) come C++ hanno immesso le eccezioni.

_se_translator_function _set_se_translator(
   _se_translator_function seTransFunction
);

Parametri

seTransFunction
Il puntatore di tipo c strutturazione della funzione di conversione di eccezione da scrivere.

Valore restituito

Restituisce un puntatore a funzione di conversione precedente registrata da _set_se_translator, in modo che la funzione precedente può essere ripristinato in un secondo momento.Se nessuna funzione precedente è stata impostata, il valore restituito può essere utilizzato per ripristinare il comportamento predefinito, questo valore può essere NULL.

Note

_set_se_translator la funzione consente di gestire Win32 le eccezioni (eccezioni strutturate C#) come eccezioni tipizzate C++.Per concedere ogni eccezione c# per gestire da C++ catch il gestore, innanzitutto definisce la classe wrapper di eccezione c che è possibile utilizzare, o essere derivato, per associare al tipo specifico della classe a eccezione di tipo c.Per utilizzare questa classe, installare una funzione di conversione personalizzata di eccezione c# definita dall'eccezione interna c il meccanismo di gestione delle eccezioni quando viene generata un'eccezione.Nella funzione di conversione, è possibile generare qualsiasi eccezione tipizzata intercettabile da una corrispondenza C++ catch gestore.

È necessario utilizzare /EHa quando si utilizzano _set_se_translator.

Per specificare una funzione personalizzata per la conversione, chiamata _set_se_translatorcon il nome della funzione di conversione come argomento.La funzione di conversione che si scrivono viene chiamata una volta per ogni chiamata di funzione nello stack che ha tryblocchi.Non esiste una funzione di conversione predefinita.

La funzione di conversione deve fare non più dell'eccezione tipizzata di un'applicazione C/C++.Se ha una funzione oltre a generare (ad esempio la scrittura in un file di log, ad esempio il programma potrebbe non avere come previsto, poiché il numero di volte in cui la funzione di conversione richiamata è dipendente dalla piattaforma.

In un ambiente multithreading, le funzioni di conversione sono gestite separatamente per ogni thread.Necessità di ogni nuove thread di installare la propria funzione di conversione.Quindi, ogni thread è responsabile della gestione della conversione._set_se_translatorè specifico di un thread; un'altra DLL possibile installare una funzione diversa della conversione.

seTransFunction l'esecuzione di scrivere è necessario essere una funzione nativo-compilata (non compilata con /clr.Deve accettare un intero senza segno e un puntatore a un oggetto Win32 _EXCEPTION_POINTERS struttura come argomenti.Gli argomenti sono i valori restituiti delle chiamate API Win32 GetExceptionCode e GetExceptionInformation funzioni, rispettivamente.

typedef void (*_se_translator_function)(unsigned int, struct _EXCEPTION_POINTERS* );

per _set_se_translator, esistono le implicazioni in modo dinamico è collegato a CRT, un'altra DLL nel processo può chiamare _set_se_translator e sostituire il gestore con i propri.

Quando si utilizzano _set_se_translator da codice gestito (codice compilato con /clr) o misto nativo e codice gestito, tenere presente che il convertitore influisce sulle eccezioni generate nel codice nativo.Eventuali eccezioni gestite generate nel codice gestito (ad esempio quando si generano System::Exception) non vengono indirizzati alla funzione di conversione.Eccezioni generate nel codice gestito utilizzando la funzione Win32 RaiseException o causato da un'eccezione di sistema come una divisione per zero eccezione sono indirizzati attraverso il traduttore.

Requisiti

routine	Intestazione di associazione
_set_se_translator	<eh.h>

la funzionalità fornita _set_se_translator non è disponibile nel codice compilato con /clr: pure opzione del compilatore.

Per ulteriori informazioni sulla compatibilità, vedere compatibilità nell'introduzione.

Esempio

// crt_settrans.cpp
// compile with: /EHa
#include <stdio.h>
#include <windows.h>
#include <eh.h>

void SEFunc();
void trans_func( unsigned int, EXCEPTION_POINTERS* );

class SE_Exception
{
private:
    unsigned int nSE;
public:
    SE_Exception() {}
    SE_Exception( unsigned int n ) : nSE( n ) {}
    ~SE_Exception() {}
    unsigned int getSeNumber() { return nSE; }
};
int main( void )
{
    try
    {
        _set_se_translator( trans_func );
        SEFunc();
    }
    catch( SE_Exception e )
    {
        printf( "Caught a __try exception with SE_Exception.\n" );
    }
}
void SEFunc()
{
    __try
    {
        int x, y=0;
        x = 5 / y;
    }
    __finally
    {
        printf( "In finally\n" );
    }
}
void trans_func( unsigned int u, EXCEPTION_POINTERS* pExp )
{
    printf( "In trans_func.\n" );
    throw SE_Exception();
}

Sebbene la funzionalità di fornire da _set_se_translator non è disponibile nel codice gestito, è possibile utilizzare questo mapping nel codice nativo, anche se il codice nativo consiste in una compilazione in /clr opzione, purché il codice nativo viene illustrato l'utilizzo di #pragma unmanaged.Se un'eccezione strutturata viene generata nel codice gestito che deve essere mappato, il codice che genera e gestire l'eccezione devono essere contrassegnati con pragma.Il codice seguente viene illustrato un possibile utilizzo.Per ulteriori informazioni, vedere Direttive pragma e la parola chiave di __Pragma.

// crt_set_se_translator_clr.cpp
// compile with: /clr
#include <windows.h>
#include <eh.h>
#include <assert.h>
#include <stdio.h>

int thrower_func(int i) {
   int j = i/0;
  return 0;
}

class CMyException{
};

#pragma unmanaged
void my_trans_func(unsigned int u, PEXCEPTION_POINTERS pExp )
{
printf("Translating the structured exception to a C++"
             " exception.\n");
throw CMyException();
}

void DoTest()
{
    try
    {
      thrower_func(10);
    } 

    catch(CMyException e)
    {
printf("Caught CMyException.\n");
    }
    catch(...)
    {
      printf("Caught unexpected SEH exception.\n");
    }
}
#pragma managed

int main(int argc, char** argv) {
    _set_se_translator(my_trans_func);
    DoTest();
    return 0;
}