Zum Hauptinhalt springen
Diese Funktion dient dazu, einen Zeiger auf die IEngine-Schnittstelle abzurufen. Als Eingabeparameter wird die Customer Project ID-Nummer übergeben, eine alphanumerische Zeichenfolge, die für alle von Ihrem Projekt verwendeten Developer- und Runtime-Lizenzen identisch ist.
Für Linux- und Windows-Benutzer ermöglicht diese Funktion bei Bedarf einen einfachen Zugriff auf die Online-Lizenzierung. Außerdem können Sie bei der Initialisierung einige zusätzliche Parameter angeben.

​
Syntax

​
C++

HRESULT __stdcall InitializeEngine(
  BSTR CustomerProjectID,
  BSTR LicensePath,
  BSTR LicensePassword,
  BSTR FREngineDataFolder,
  BSTR FREngineTempFolder,
  VARIANT_BOOL IsSharedCPUCoresMode,
  IEngine** Engine
);

​
C#

int InitializeEngine(
  string CustomerProjectID,
  string LicensePath,
  string LicensePassword,
  string FREngineDataFolder,
  string FREngineTempFolder,
  bool IsSharedCPUCoresMode,
  ref IEngine Engine
);

​
Visual Basic .NET

Private Declare Function InitializeEngine Lib "FREngine.dll" ( _
  CustomerProjectID As String, _
  LicensePath As String, _
  LicensePassword As String, _
  FREngineDataFolder As String, _
  FREngineTempFolder As String, _
  IsSharedCPUCoresMode As Boolean, _
  ByRef Engine As FREngine.IEngine) _
As Integer

​
Parameter

CustomerProjectID [in] Ein string mit der Customer Project ID.
Während der Initialisierung der Bibliothek wird die Liste aller verfügbaren Lizenzen nach einer Developer- oder Runtime-Lizenz durchsucht, die dieser Customer Project ID entspricht. Wird keine entsprechende Lizenz gefunden, tritt ein Fehler für die zuletzt geprüfte Lizenz auf. Sie können für diesen Parameter jedoch auch 0 übergeben und die Lizenz später auswählen, indem Sie vor allen anderen Bibliotheksmethoden die Methode IEngine::SetCurrentLicense aufrufen.
LicensePath [in] Der vollständige Dateiname der Online-Lizenzdatei. Wenn Sie keine Online-Lizenz verwenden, übergeben Sie stattdessen eine leere Zeichenfolge "" oder einen Nullzeiger. Es ist also eine leere Zeichenfolge "" oder ein Nullzeiger zu übergeben. Für macOS-Benutzer: Dieser Parameter ist für die zukünftige Verwendung reserviert. LicensePassword [in] Das Kennwort der Online-Lizenz. Wenn Sie keine Online-Lizenz verwenden, übergeben Sie stattdessen eine leere Zeichenfolge "" oder einen Nullzeiger. Für macOS-Benutzer: Dieser Parameter ist für die zukünftige Verwendung reserviert. FREngineDataFolder [in] Enthält den Pfad zu dem Ordner, in dem ABBYY FineReader Engine benutzerspezifische Daten speichern soll. Standardmäßig bei automatischer Installation: %ProgramData%\ABBYY\SDK\12\FineReader Engine for auxiliary engine data Zusätzlich für Linux und Windows: %ProgramData%\ABBYY\SDK\12\Licenses for license data Wenn Sie den Wert für FREngineDataFolder festlegen, werden alle zusätzlichen Informationen in einen neuen Datenordner geschrieben. Möglicherweise müssen Sie den Standardwert ändern, zum Beispiel wenn die Spracheinstellungen der Benutzeroberfläche Ihrer Anwendung von denen anderer Anwendungen abweichen müssen, die FineReader Engine verwenden. Nachdem Sie den Standardwert geändert haben, stellen Sie sicher, dass Sie Vollzugriffsberechtigungen für den neuen Datenordner haben. FREngineTempFolder [in] Enthält den Pfad zu dem Ordner für temporäre Dateien von ABBYY FineReader Engine. Standardmäßig ist dies der Ordner %TEMP%\ABBYY FineReader Engine 12. IsSharedCPUCoresMode [in] Gibt an, ob die CPU-Kerne im gemeinsamen Modus verwendet werden sollen. Es gibt zwei Modi für die Nutzung der CPU-Kerne: getrennt und gemeinsam. Im getrennten Modus verwendet ABBYY FineReader Engine nicht mehr Prozesse, als durch die Lizenz zulässig sind. Im gemeinsamen Modus kann eine beliebige Anzahl von Prozessen ausgeführt werden, aber all diese Prozesse verwenden nur die CPU-Kerne, die durch die Eigenschaft IMultiProcessingParams::SharedCPUCoresMask angegeben sind.
Dieser Parameter wird in ABBYY FineReader Engine für Windows ignoriert.
Engine [out, retval] Ein Zeiger auf eine IEngine*-Zeigervariable, die den Schnittstellenzeiger auf das resultierende Engine-Objekt empfängt.

​
Rückgabewerte

Die Funktion kann die standardmäßigen Rückgabewerte der ABBYY FineReader Engine-Funktionen zurückgeben.

​
Hinweise

Mit dieser Funktion kann in einer einzelnen Instanz der Anwendung, die ABBYY FineReader Engine verwendet, nur ein Engine-Objekt erstellt werden. Wiederholte Versuche, das Engine-Objekt zu erstellen, geben dasselbe Objekt zurück.
Das Erstellen des Engine-Objekts kann merklich Zeit in Anspruch nehmen. Während der Initialisierung lädt die Engine die unten aufgeführte Hauptbibliothek sowie eine große Anzahl zusätzlicher dynamischer Bibliotheken:
  • Linux: libFREngine.so
  • macOS: libFREngine.dylib
  • Windows: FREngine.dll
Bei Verwendung einer Netzwerklizenz kann die Initialisierung unter Linux und Windows aufgrund der Kommunikation mit dem Lizenzserver ebenfalls länger dauern. Stellen Sie sicher, dass die Netzwerkverbindung die erforderliche Leistung erbringt; für einen zuverlässigen Betrieb mit einer Netzwerklizenz wird eine Bandbreite von mindestens 100 Kb/s empfohlen.
Das Engine-Objekt kann auf einem Mehrprozessorsystem erstellt und ausgeführt werden, jedoch kann in jedem Prozess nur ein Engine-Objekt vorhanden sein. Ein zweiter Aufruf von InitializeEngine innerhalb desselben Prozesses gibt die Referenz auf das vorhandene Objekt zurück. Daher sollten Sie für jeden Prozess ein separates Engine-Objekt erstellen, indem Sie die Funktion InitializeEngine aufrufen.
Für ABBYY FineReader Engine für Windows-Implementierungen mit Mehrprozessorsystemen können andere Methoden zum Laden des Engine-Objekts hilfreich sein.
Initialisieren und deinitialisieren Sie ABBYY FineReader Engine nicht an den Einstiegspunkten anderer dynamischer Bibliotheken sowie nicht in Konstruktoren und Destruktoren von statischen und globalen Objekten, die in dynamischen Bibliotheken implementiert sind, da diese an den Einstiegspunkten der dynamischen Bibliothek aufgerufen werden.
ABBYY FineReader Engine sollte an anderer Stelle initialisiert und deinitialisiert werden – beispielsweise in der main- oder WinMain-Funktion eines ausführbaren Moduls.
: Unter Windows ist diese Einschränkung darauf zurückzuführen, dass die Win32-Funktionen LoadLibrary und FreeLibrary nicht re-entrant sind.
Während der Initialisierung setzt ABBYY FineReader Engine die LC_CTYPE-Einstellung auf die Standardwerte des Betriebssystems zurück. Dies sollte berücksichtigt werden, wenn Ihre Anwendung von gebietsschemaabhängigen Diensten abhängt (insbesondere msvcrt.dll unter Windows). Windows-Entwickler, die .NET verwenden, müssen sicherstellen, dass [STAThread] (Single-Thread-Apartment-Modell) als Attribut für die Hauptfunktion der Anwendung angegeben wird; andernfalls kann ein Fehler auftreten: 
[STAThread]
public static void Main()
{
  ...
}
Sie sollten eine gültige Customer Project ID als Eingabeparameter übergeben. Sie können jedoch auch festlegen, welche Lizenz für die Verarbeitung verwendet werden soll, indem Sie vor allen Verarbeitungsmethoden die SetCurrentLicense-Methode des Engine-Objekts aufrufen. Verwenden Sie die GetAvailableLicenses-Methode, um die Liste der verfügbaren aktivierten Lizenzen einzusehen, die Sie verwenden können, und die CurrentLicense-Eigenschaft des Engine-Objekts, um zu prüfen, welche Lizenz aktuell ausgewählt ist.

​
Beispiele

// Initialisieren Sie diese Variablen mit dem Pfad zu FREngine.dll, Ihrer FineReader Engine Customer Project ID
// und gegebenenfalls mit dem Pfad zum Online-Lizenz-Token und zum Kennwort der Online-Lizenz
wchar_t* FreDllPath;
wchar_t* CustomerProjectId;
wchar_t* LicensePath;  // wenn Sie keine Online-Lizenz verwenden, weisen Sie diesen Variablen leere Zeichenfolgen zu
wchar_t* LicensePassword;
// HANDLE für FREngine.dll
static HMODULE libraryHandle = 0;
// Globales FineReader Engine-Objekt.
FREngine::IEnginePtr Engine;
void LoadFREngine()
{
    if( Engine != 0 ) {
    // Bereits geladen
    return;
    }
    // Erster Schritt: FREngine.dll laden
    if( libraryHandle == 0 ) {
        libraryHandle = LoadLibraryEx( FreDllPath, 0, LOAD_WITH_ALTERED_SEARCH_PATH );
        if( libraryHandle == 0 ) {
            throw L"Fehler beim Laden von ABBYY FineReader Engine";
        }
    }
    // Zweiter Schritt: das Engine-Objekt abrufen
    typedef HRESULT ( STDAPICALLTYPE* InitializeEngineFunc )( BSTR, BSTR, BSTR, BSTR, 
        BSTR, VARIANT_BOOL, FREngine::IEngine** );
    InitializeEngineFunc pInitializeEngine =
    ( InitializeEngineFunc )GetProcAddress( libraryHandle, "InitializeEngine" );
    if( pInitializeEngine == 0 || pInitializeEngine( CustomerProjectId, LicensePath, 
        LicensePassword, L"", L"", VARIANT_FALSE, &Engine ) != S_OK ) {
    UnloadFREngine();
    throw L"Fehler beim Laden von ABBYY FineReader Engine";
    }
}

public class EngineLoader : IDisposable
{
    public EngineLoader()
    {
        // Initialisieren Sie diese Variablen mit dem vollständigen Pfad zu FREngine.dll, Ihrer Customer Project ID
        // sowie ggf. mit dem Pfad zu Ihrer Online-Lizenz-Token-Datei und dem Kennwort der Online-Lizenz
        string enginePath = "";
        string customerProjectId = "";
        string licensePath = "";
        string licensePassword = "";
        // Die Bibliothek FREngine.dll laden
        dllHandle = LoadLibraryEx(enginePath, IntPtr.Zero, LOAD_WITH_ALTERED_SEARCH_PATH);
           
        try
        {
            if (dllHandle == IntPtr.Zero)
            {
                throw new Exception("Can't load " + enginePath);
            }
            IntPtr initializeEnginePtr = GetProcAddress(dllHandle, "InitializeEngine");
            if (initializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Can't find InitializeEngine function");
            }
            IntPtr deinitializeEnginePtr = GetProcAddress(dllHandle, "DeinitializeEngine");
            if (deinitializeEnginePtr == IntPtr.Zero)
            {
                throw new Exception("Can't find DeinitializeEngine function");
            }
            IntPtr dllCanUnloadNowPtr = GetProcAddress(dllHandle, "DllCanUnloadNow");
            if (dllCanUnloadNowPtr == IntPtr.Zero)
            {
                throw new Exception("Can't find DllCanUnloadNow function");
            }
            // Zeiger in Delegates konvertieren
            initializeEngine = (InitializeEngine)Marshal.GetDelegateForFunctionPointer(
                initializeEnginePtr, typeof(InitializeEngine));
            deinitializeEngine = (DeinitializeEngine)Marshal.GetDelegateForFunctionPointer(
                deinitializeEnginePtr, typeof(DeinitializeEngine));
            dllCanUnloadNow = (DllCanUnloadNow)Marshal.GetDelegateForFunctionPointer(
                dllCanUnloadNowPtr, typeof(DllCanUnloadNow));
            // Die Funktion InitializeEngine aufrufen 
            // und dabei den Pfad zur Online-Lizenzdatei sowie das Kennwort der Online-Lizenz übergeben
            int hresult = initializeEngine(customerProjectId, licensePath, licensePassword, 
                "", "", false, ref engine);
            Marshal.ThrowExceptionForHR(hresult);
        }
        catch (Exception)
        {
            // Die Bibliothek FREngine.dll freigeben
            engine = null;
            // Vor dem Aufruf von FreeLibrary alle Objekte löschen
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            FreeLibrary(dllHandle);
            dllHandle = IntPtr.Zero;
            initializeEngine = null;
            deinitializeEngine = null;
            dllCanUnloadNow = null;
            throw;
        }
    }
    // Funktionen aus Kernel32.dll
    [DllImport("kernel32.dll")]
    private static extern IntPtr LoadLibraryEx(string dllToLoad, IntPtr reserved, uint flags);
    private const uint LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
    [DllImport("kernel32.dll")]
    private static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    [DllImport("kernel32.dll")]
    private static extern bool FreeLibrary(IntPtr hModule);
    // Funktionen aus FREngine.dll
    [UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
    private delegate int InitializeEngine(string customerProjectId, string licensePath, 
        string licensePassword, string tempFolder, string dataFolder, bool isSharedCPUCoresMode, 
        ref FREngine.IEngine engine);
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DeinitializeEngine();
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    private delegate int DllCanUnloadNow();
    // private Variablen
    private FREngine.IEngine engine = null;
    // Handle für FREngine.dll
    private IntPtr dllHandle = IntPtr.Zero;
    private InitializeEngine initializeEngine = null;
    private DeinitializeEngine deinitializeEngine = null;
    private DllCanUnloadNow dllCanUnloadNow = null;
}
Die Funktion wird in allen Codebeispielen mit Ausnahme von EnginesPool (Win) verwendet.

​
Siehe auch

Lizenzierung Module DeinitializeEngine Verschiedene Möglichkeiten zum Laden des Engine-Objekts (Win)