使用syscall.SyscallN替代syscall.Syscall的Golang实践指南

// 补充一个完整的示例，展示如何使用syscall.SyscallN调用Windows API
package main

import (
    "fmt"
    "syscall"
    "unsafe"
    "golang.org/x/sys/windows"
)

var (
    kernel32         = syscall.NewLazyDLL("kernel32.dll")
    procGetTempPathW = kernel32.NewProc("GetTempPathW")
)

// 封装GetTempPathW API
func GetTempPath() (string, error) {
    var buffer [windows.MAX_PATH]uint16
    
    // 使用SyscallN调用，注意参数转换
    r0, _, e1 := syscall.SyscallN(
        procGetTempPathW.Addr(),
        uintptr(windows.MAX_PATH),
        uintptr(unsafe.Pointer(&buffer[0])),
    )
    
    if r0 == 0 {
        return "", e1
    }
    
    return windows.UTF16ToString(buffer[:r0]), nil
}

// 示例：调用自定义DLL函数
var (
    customDll     *syscall.LazyDLL
    customProc    *syscall.LazyProc
)

func init() {
    customDll = syscall.NewLazyDLL("custom.dll")
    customProc = customDll.NewProc("CalculateSum")
}

// 假设DLL函数签名：int CalculateSum(int a, int b)
func CalculateSum(a, b int32) int32 {
    r0, _, _ := syscall.SyscallN(
        customProc.Addr(),
        uintptr(a),
        uintptr(b),
    )
    return int32(r0)
}

// 处理字符串参数的示例
func ProcessString(input string) (string, error) {
    proc := customDll.NewProc("ProcessStringW")
    
    // 转换Go字符串为UTF-16指针
    inputPtr, err := windows.UTF16PtrFromString(input)
    if err != nil {
        return "", err
    }
    
    var outputBuffer [256]uint16
    
    r0, _, e1 := syscall.SyscallN(
        proc.Addr(),
        uintptr(unsafe.Pointer(inputPtr)),
        uintptr(unsafe.Pointer(&outputBuffer[0])),
        uintptr(len(outputBuffer)),
    )
    
    if r0 == 0 {
        return "", e1
    }
    
    return windows.UTF16ToString(outputBuffer[:]), nil
}

func main() {
    // 示例1：调用系统API
    tempPath, err := GetTempPath()
    if err != nil {
        fmt.Printf("获取临时路径失败: %v\n", err)
    } else {
        fmt.Printf("临时路径: %s\n", tempPath)
    }
    
    // 示例2：调用自定义DLL
    sum := CalculateSum(10, 20)
    fmt.Printf("计算结果: %d\n", sum)
    
    // 示例3：处理字符串
    result, err := ProcessString("test input")
    if err != nil {
        fmt.Printf("处理字符串失败: %v\n", err)
    } else {
        fmt.Printf("处理结果: %s\n", result)
    }
}

// 处理不同参数类型的示例
func CallWithVariedParams() {
    proc := customDll.NewProc("VariedParamsFunc")
    
    // 不同类型参数的转换示例
    intParam := int32(100)
    uintParam := uint32(200)
    boolParam := true
    floatParam := float32(3.14)
    stringParam := "test"
    
    // 字符串转换为指针
    strPtr, _ := windows.UTF16PtrFromString(stringParam)
    
    // 结构体参数示例
    type MyStruct struct {
        Field1 int32
        Field2 uintptr
    }
    structParam := &MyStruct{Field1: 1, Field2: 2}
    
    // 使用SyscallN调用
    r0, _, _ := syscall.SyscallN(
        proc.Addr(),
        uintptr(intParam),           // int32
        uintptr(uintParam),          // uint32
        uintptr(boolToUintptr(boolParam)), // bool
        uintptr(*(*uint32)(unsafe.Pointer(&floatParam))), // float32
        uintptr(unsafe.Pointer(strPtr)),    // string
        uintptr(unsafe.Pointer(structParam)), // struct
    )
    
    fmt.Printf("返回值: %d\n", int32(r0))
}

func boolToUintptr(b bool) uintptr {
    if b {
        return 1
    }
    return 0
}

// 处理回调函数的示例
func CallWithCallback() {
    proc := customDll.NewProc("RegisterCallback")
    
    // 定义回调函数
    callback := syscall.NewCallback(func(param uintptr) uintptr {
        fmt.Printf("回调被调用，参数: %d\n", param)
        return param + 1
    })
    
    // 调用DLL函数，传递回调
    r0, _, _ := syscall.SyscallN(
        proc.Addr(),
        callback,
    )
    
    fmt.Printf("注册回调结果: %d\n", int32(r0))
}

// 错误处理的最佳实践
func SafeDllCall() (result int32, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("DLL调用panic: %v", r)
        }
    }()
    
    proc := customDll.NewProc("SomeFunction")
    
    // 检查过程是否有效
    if proc == nil {
        return 0, fmt.Errorf("未找到过程")
    }
    
    r0, _, e1 := syscall.SyscallN(proc.Addr())
    
    // 检查Windows错误
    if e1 != nil && e1.(syscall.Errno) != 0 {
        return int32(r0), e1
    }
    
    return int32(r0), nil
}