c#調用java 怎樣處理復雜對象

在C#中調用Java方法并處理復雜對象，可以使用以下步驟：

1. 定義Java類和復雜對象：

首先，在Java中定義一個類和復雜對象。例如，我們創建一個名為Person的類：

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2. 使用Java Native Interface (JNI)：

為了在C#中調用Java方法，需要使用JNI。JNI是Java提供的一種標準，允許本地代碼（如C#）與Java代碼進行交互。首先，需要創建一個Java本地接口（JNI）類，用于處理C#與Java之間的交互。

public class JniWrapper {
    static {
        System.loadLibrary("jniwrapper");
    }

    public native Person createPerson(String name, int age);
    public native void setName(Person person, String name);
    public native int getAge(Person person);
}

接下來，需要使用javac命令編譯這個類，并使用javah命令生成JNI頭文件。然后，使用C語言編寫實現這些方法的本地代碼。

3. 創建C# DLL：

接下來，需要創建一個C# DLL，用于實現JNI本地方法。首先，創建一個名為JniWrapperImpl.cs的文件，包含以下內容：

using System;
using System.Runtime.InteropServices;

public class JniWrapperImpl : JniWrapper {
    [DllImport("jniwrapper", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr createPerson(string name, int age);

    [DllImport("jniwrapper", CallingConvention = CallingConvention.Cdecl)]
    private static extern void setName(IntPtr personPtr, string name);

    [DllImport("jniwrapper", CallingConvention = CallingConvention.Cdecl)]
    private static extern int getAge(IntPtr personPtr);

    public override Person createPerson(string name, int age) {
        return new Person(name, age);
    }

    public override void setName(Person person, string name) {
        setName(person.GetHashCode(), name);
    }

    public override int getAge(Person person) {
        return getAge(person.GetHashCode());
    }
}

然后，創建一個名為JniWrapper.cs的文件，包含以下內容：

using System;

public class JniWrapper {
    public delegate Person CreatePersonDelegate(string name, int age);
    public delegate void SetNameDelegate(Person person, string name);
    public delegate int GetAgeDelegate(Person person);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate IntPtr CreatePersonNativeDelegate(string name, int age);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate void SetNameNativeDelegate(IntPtr personPtr, string name);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate int GetAgeNativeDelegate(IntPtr personPtr);

    public CreatePersonDelegate CreatePerson { get; set; }
    public SetNameDelegate SetName { get; set; }
    public GetAgeDelegate GetAge { get; set; }

    static JniWrapper() {
        CreatePerson = new CreatePersonDelegate(CreatePersonNative);
        SetName = new SetNameDelegate(SetNameNative);
        GetAge = new GetAgeDelegate(GetAgeNative);
    }

    private static IntPtr CreatePersonNative(string name, int age) {
        return Marshal.AllocHGlobal(Marshal.SizeOf(new Person(name, age)));
    }

    private static void SetNameNative(IntPtr personPtr, string name) {
        var person = (Person)Marshal.PtrToStructure(personPtr, typeof(Person));
        person.setName(name);
        Marshal.StructureToPtr(person, personPtr, false);
    }

    private static int GetAgeNative(IntPtr personPtr) {
        var person = (Person)Marshal.PtrToStructure(personPtr, typeof(Person));
        return person.getAge();
    }
}

接下來，使用csc命令編譯這個C# DLL。

4. 在C#中使用Java類：

現在，可以在C#中使用JniWrapper類來調用Java方法并處理復雜對象。首先，創建一個名為Program.cs的文件，包含以下內容：

using System;

class Program {
    static void Main(string[] args) {
        JniWrapper jniWrapper = new JniWrapper();
        Person person = jniWrapper.CreatePerson("John Doe", 30);
        Console.WriteLine($"Name: {person.getName()}, Age: {person.getAge()}");

        jniWrapper.SetName(person, "Jane Doe");
        Console.WriteLine($"Name: {person.getName()}, Age: {person.getAge()}");
    }
}

最后，使用csc命令編譯這個C#程序，并運行它。這將調用Java方法并處理復雜對象。