Electron.NET

starred/Electron.NET

Fork 0

mirror of https://github.com/ElectronNET/Electron.NET.git synced 2026-02-09 21:24:55 +00:00

Table of Contents

Overview
Methods

🧊 void Call(string socketEventName, params dynamic[] arguments)
🧊 Task<T> CallAsync<T>(string socketEventName, params dynamic[] arguments)

Usage Examples

Basic Host Hook Execution
Advanced Integration
Error Handling
Type-Safe Operations
Custom ElectronHostHook Setup
Integration with .NET Code

Related APIs
Additional Resources

Execute native JavaScript/TypeScript code from the host process.

Overview

The Electron.HostHook API allows you to execute native JavaScript/TypeScript code from the host process. This enables advanced integration scenarios where you need to run custom JavaScript code or access Node.js APIs directly.

Methods

🧊 `void Call(string socketEventName, params dynamic[] arguments)`

Execute native JavaScript/TypeScript code synchronously.

Parameters:

socketEventName - Socket name registered on the host
arguments - Optional parameters

🧊 `Task<T> CallAsync<T>(string socketEventName, params dynamic[] arguments)`

Execute native JavaScript/TypeScript code asynchronously with type-safe return values.

Parameters:

T - Expected return type
socketEventName - Socket name registered on the host
arguments - Optional parameters

Returns:

Task with the result from the executed host code.

Usage Examples

Basic Host Hook Execution

// Execute simple JavaScript function
Electron.HostHook.Call("myFunction", "parameter1", 42);

// Execute with callback-style result
var result = await Electron.HostHook.CallAsync<string>("getUserName", userId);
Console.WriteLine($"User name: {result}");

Advanced Integration

// Call custom Electron API
var fileContent = await Electron.HostHook.CallAsync<string>("readFile", "config.json");
Console.WriteLine($"Config: {fileContent}");

// Execute with multiple parameters
var processedData = await Electron.HostHook.CallAsync<object[]>("processData", rawData, options);

// Call with complex objects
var settings = new { theme = "dark", language = "en" };
var updatedSettings = await Electron.HostHook.CallAsync<object>("updateSettings", settings);

Error Handling

try
{
    // Execute host function with error handling
    var result = await Electron.HostHook.CallAsync<string>("riskyOperation", inputData);
    Console.WriteLine($"Success: {result}");
}
catch (Exception ex)
{
    // Handle execution errors
    Console.WriteLine($"Host hook error: {ex.Message}");
    Electron.Dialog.ShowErrorBox("Operation Failed", "Could not execute host function.");
}

Type-Safe Operations

// Strongly typed return values
var userInfo = await Electron.HostHook.CallAsync<UserInfo>("getUserInfo", userId);
Console.WriteLine($"User: {userInfo.Name}, Email: {userInfo.Email}");

// Array results
var fileList = await Electron.HostHook.CallAsync<string[]>("listFiles", directoryPath);
foreach (var file in fileList)
{
    Console.WriteLine($"File: {file}");
}

// Complex object results
var systemStats = await Electron.HostHook.CallAsync<SystemStatistics>("getSystemStats");
Console.WriteLine($"CPU: {systemStats.CpuUsage}%, Memory: {systemStats.MemoryUsage}%");

Custom ElectronHostHook Setup

// In your ElectronHostHook/index.ts
import { app } from 'electron';

export function getAppVersion(): string {
    return app.getVersion();
}

export async function readConfigFile(): Promise<string> {
    const fs = require('fs').promises;
    return await fs.readFile('config.json', 'utf8');
}

export function customNotification(message: string): void {
    // Custom notification logic
    console.log(`Custom notification: ${message}`);
}

Integration with .NET Code

// Use host hook in your application logic
public async Task<string> GetApplicationVersion()
{
    return await Electron.HostHook.CallAsync<string>("getAppVersion");
}

public async Task LoadConfiguration()
{
    try
    {
        var config = await Electron.HostHook.CallAsync<ConfigObject>("readConfigFile");
        ApplyConfiguration(config);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to load config: {ex.Message}");
        UseDefaultConfiguration();
    }
}

public void ShowCustomNotification(string message)
{
    Electron.HostHook.Call("customNotification", message);
}