unity面试八股文 - 基础篇

委托是什么? event 关键字有什么用？

委托：
委托是一种特殊类型的对象，它包含了对一个方法的引用。简单来说，委托就像是一个安全的函数指针。它允许我们创建可在运行时动态更改其引用方法的变量，并且可以指向类中定义的任何具有相同签名（即参数类型和返回类型）的方法。

Event ：
"Event"关键字在C#或其他面向对象编程语言中常被使用, 它主要用于发布/订阅模式（也称为观察者模式）。当某个重要事件（比如点击按钮、文件下载完成等）发生时，程序需要通知其他部分进行相应处理。这时候就会使用到"Event"关键字来声明事件，并通过调用这个事件来通知所有订阅了该事件（即注册了该事件处理器）的代码块。

Unity协程是如何实现的

Unity中的协程是一种特殊类型的函数，可以在给定的时间段内多次返回。它们在某些情况下非常有用，比如当你需要对一个操作进行计时或者延迟执行。

以下是Unity协程实现的基本步骤：

创建协程函数：首先，你需要创建一个返回IEnumerator接口类型的函数。这个接口允许你控制代码何时暂停和恢复。

IEnumerator MyCoroutine()
{
    // 这里写入你想要执行的代码
    yield return null; // 暂停并在下一帧继续
}
1
2
3
4
5

启动协程：使用StartCoroutine()方法启动定义好的协程。

StartCoroutine(MyCoroutine());
1

控制流：通过yield关键字来控制代码执行流。例如：

• yield return null：暂停当前帧，并在下一帧恢复。
• yield return new WaitForSeconds(1)：暂停1秒后恢复。
• yield return StartCoroutine(“AnotherCoroutine”)：
  开始另一个协程，并等待它完成后再继续。
  以上就是Unity中实现和使用协程的基本方式。请注意，虽然看起来像多线程编程，但实际上所有Unity API调用都必须在主线程上完成，因此不会遇到常规多线程序可能遇到的并发问题。

摄像机有几种模式，成像原理分别是什么？

摄像机（Camera）有三种模式：正交投影模式（Orthographic）、透视投影模式（Perspective）和物理相机（Physical Camera）。

• 正交投影模式：
  在这种模式下，摄像机将场景以平行线方式进行投影。这种方式没有透视效果，即远离或靠近摄像头的物体大小不会改变。这种模式通常用于2D游戏或者需要特殊视觉效果的3D游戏。

• 透视投影模式：
  在此设置下，摄像机将场景以收敛线方式进行投影。也就是说，远离镜头的物体会显得更小。这就产生了一种深度感或者三维空间感觉，使得画面看起来更加真实立体。

• 物理相机：
  从Unity 2018版本开始引入了"Physical Camera"属性, 可以让你设置镜头、传感器和其他一些参数, 更接近现实世界中相机的工作原理.

在Unity中，“成像原理”主要依赖于渲染管线(Render Pipeline)来完成。当你启动一个Scene时, Unity首先创建一个包含所有对象数据(位置、纹理、光照等)的渲染队列(Render Queue), 然后通过Shader程序对每个物体进行处理并生成图形数据, 最后由GPU根据这些数据生成最终图像并显示到屏幕上.

Canvas 有几种模式，如何配置？

Canvas是用于布局和渲染所有UI元素的组件。它有三种模式：

• 世界空间（World Space）：在这种模式下，Canvas表现为任何常规的3D对象一样。你可以自由地移动、旋转、缩放它。这种模式通常用于3D游戏中的交互UI或者VR应用。

• 屏幕空间-覆盖（Screen Space - Overlay）：这是默认的Canvas模式。在此模式下，Canvas将覆盖屏幕，并始终对准摄像机视野的前方，无论摄像机如何移动或旋转。当你需要全屏显示UI元素时，比如菜单、得分板等，这个选项非常实用。

• 屏幕空间-相机（Screen Space - Camera）：此模式将Canvas渲染到特定摄像头的平面上，并随着摄像头移动而变化位置和大小。

UGUI如何打包图集

在Unity 2018及以后的版本中，Unity引入了新的系统"Sprite Atlas"来替代旧的"Sprite Packer"。以下是使用新版Sprite Atlas打包图集的步骤：

在Project窗口中右键点击 -> Create -> Sprite Atlas，创建一个新的Sprite Atlas对象。

将所有需要打包成图集的图片拖动到这个新建立的Sprite Atlas对象上，在Inspector窗口中可以看到Objects for Packing区域，里面列出了你添加进来的所有图片。

在Inspector窗口可以看到Pack Preview按钮, 点击它可以预览打包效果。如果满意，则可以保存并关闭预览。

在编写脚本或者配置UI元素时引用这些Sprite时, Unity会自动使用它们在图集中对应部分, 而不再是单独加载原始小图片。

如果你想要手动控制何时进行打包操作，也可以通过编程方式调用UnityEditor.U2D.SpriteAtlasUtility.PackAtlases()函数进行手动打包。注意这个函数只能在编辑器环境下使用，并且需要添加#if UNITY_EDITOR和#endif标记防止在构建游戏时产生错误。

UGUI 如何实现UI物体淡入淡出

在Unity的UGUI系统中，实现UI物体的淡入淡出效果可以通过调整Canvas Group组件或者Image和Text组件自身的Alpha值来达到。这里以Canvas Group为例，演示如何使用C#脚本实现：

首先，在你想要进行淡入淡出操作的UI物体上添加一个Canvas Group组件。

然后创建一个新的C#脚本，例如命名为FadeInOut，并把以下代码粘贴进去：

using System.Collections;
using UnityEngine;
using UnityEngine.UI;

public class FadeInOut : MonoBehaviour
{
    public float fadeSpeed = 0.5f; // 控制淡入淡出速度

    private CanvasGroup canvasGroup;

    void Start()
    {
        canvasGroup = GetComponent<CanvasGroup>();
        StartCoroutine(FadeIn());
    }

    IEnumerator FadeIn()
    {
        while (canvasGroup.alpha < 1)
        {
            canvasGroup.alpha += Time.deltaTime * fadeSpeed;
            yield return null;
        }
        
        yield return new WaitForSeconds(2); // 淡入完成后等待两秒开始执行淡出
        
        StartCoroutine(FadeOut());
    }

     IEnumerator FadeOut()
     {
         while (canvasGroup.alpha > 0)
         {
             canvasGroup.alpha -= Time.deltaTime * fadeSpeed;
             yield return null;
         }
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

最后，将这个脚本附加到你刚才添加了Canvas Group组件的UI物体上，并设置好fadeSpeed参数即可。

运行游戏时，该UI物体就会以指定速度进行一次完整的从完全透明（alpha=0）到完全不透明（alpha=1）再回到完全透明（alpha=0）的过程。如果你需要在特定事件触发时进行此效果，则需要稍微修改以上代码结构来满足需求。

Hash表的原理是什么, 如何实现

哈希表(HashTable)也被称为散列表，是一种数据结构，它提供了快速插入、删除和查找操作的功能。哈希表通过使用哈希函数将键(Key)映射到存储位置，然后在这个位置存储值(Value)。

这是一个简单的示例来解释它是如何工作的：

假设我们有一个空的哈希表，并且我们想要在其中添加一个元素，例如（“name”, “John”）。
我们首先将键(“name”)输入到哈希函数中。这个函数会返回一个数字（假设返回3），我们把值(“John”)存储在数组索引为3的位置上。
当我们想要查找键为"name"对应的值时，我们再次使用同样的哈希函数处理键(“name”)，得到相同的数字(3)，然后直接访问数组索引为3处获取其对应值即可。
实现基本步骤如下：

• 初始化：
  创建一个足够大容量（通常大于预期元素数量）且初始全部为空或特定标记值（例如null） 的数组用于存放数据。

• 插入：
  当需要插入新元素时, 先通过hash 函数计算出该元素key 对应 hashcode, 然后根据 hashcode 找到在数组中对应下标位置并将value 存放进去.

• 查找：
  当需要查找某个key 对应value 时, 同样先计算出该key 对应hashcode, 再根据hashcode 找到对应下标并读取value.

• 删除：
  删除则与查找类似, 先定位到具体位置然后再进行删除操作.

不过需要注意，在实际情况中可能会发生所谓“碰撞”现象——即两个不同Key经过Hash Function计算得出相同HashCode导致他们试图占用同一块内存地址。
解决碰撞问题主要有两种方法：“开放寻址法”和“链地址法”。

• 开放寻址法就是如果发生碰撞，则向前或向后探测其他空位；
• 链地址法则是每个Hash槽里面维护了一个链表或者其他数据结构，在碰撞时就把Value添加进对应槽位里面去。

实际使用中还需要考虑扩容、缩容、哈希函数设计等问题。

链表如何实现

链表是一种动态数据结构，它使用节点（Node）来存储数据。每个节点包含两个部分：一个是数据域，用于保存数据；另一个是指针域，用于链接到下一个节点。这种结构使得在任何位置插入或删除元素都变得相对容易。

在C#中，链表的实现相对简单，因为它提供了内建的LinkedList类。但是如果你想自己实现一个链表，那么可以按照以下步骤操作：

定义节点(Node)类：

public class Node
{
    public int Data { get; set; }
    public Node Next { get; set; }

    public Node(int data)
    {
        this.Data = data;
        this.Next = null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

定义链表(LinkedList)类，并实现添加(add)、删除(delete)等方法：

public class LinkedList
{
    private Node head;

    public LinkedList()
    {
        this.head = null;
    }

    // 添加节点到链表尾部
    public void AddLast(int data)
    {
        Node newNode = new Node(data);

        if (head == null)
            head = newNode;
        else
        {
            Node current = head;

            while (current.Next != null)
                current = current.Next;

            current.Next = newNode;
        }
        
    }

   // 删除特定值的节点（假设值唯一）
    public void DeleteNode(int key)
   {
       // 如果头结点就是要删除的结点 
       if(head != null && head.Data == key)
       {
           head= head.Next;
           return ;
       }

       // 其他情况，找到要删除结点前面一个结点prev和要删除结点current 
      Node prev=null, current=head ;
      while(current!=null && current.Data!=key){
          prev=current ;
          current=current.Next ;
      } 

     // 如果找不到这样的结点，则返回 
     if(current==null)return ;

     // 跳过当前要删除的节点 
     prev.next=current.next ;   

   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

Unity节点缓存池如何实现

在Unity中，对象池（Object Pool）是一种常用的优化技术，可以减少实例化和销毁对象的开销。以下是一个简单的Unity节点缓存池实现：

首先，创建一个新的C#脚本并命名为ObjectPooler，然后添加以下代码：

using System.Collections.Generic;
using UnityEngine;

public class ObjectPooler : MonoBehaviour
{
    public static ObjectPooler Instance;

    public GameObject pooledObject;
    public int pooledAmount = 20;
    public bool willGrow = true;

    List<GameObject> pooledObjects;

    void Awake()
    {
        Instance = this;
    }

    void Start ()
    {
        pooledObjects = new List<GameObject>();
        for (int i = 0; i < pooledAmount; i++)
        {
            GameObject obj = (GameObject)Instantiate(pooledObject);
            obj.SetActive(false);
            pooledObjects.Add(obj);
        }
    }

    public GameObject GetPooledObject()
    {
        for (int i=0; i<pooledObjects.Count; i++)
        {
            if (!pooledObjects[i].activeInHierarchy)
            {
                return pooledObjects[i];
            }
        }

        if (willGrow)
        {
            GameObject obj = (GameObject)Instantiate(pooledObject);
            obj.SetActive(false);
            pooledObjects.Add(obj);
            return obj;
        }
        
        return null;
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

这个脚本会创建并管理一个指定类型的游戏对象(GameObject)列表。它首先预加载一定数量(pooledAmount)的游戏对象，并将它们设置为非激活状态。当你需要从池中获取一个对象时，它会遍历列表并返回第一个非激活状态的对象。

如果所有对象都处于激活状态，并且willGrow属性设置为true，则该脚本将实例化一个新的游戏对象，并添加到列表中。

注意：在使用时，请确保已经把要生成物体预制体拖入到pooledObject位置上，并且在使用完物体后记得把物体设为非激活状态以便再次使用。

更复杂的
对于复制一点的需求，你可能是想要创建一个能够存储和管理多种类型游戏对象的对象池。这可以通过在我们先前示例的基础上进行扩展来实现。

首先，我们需要创建一个新的类来存储每种类型游戏对象的信息：

[System.Serializable]
public class ObjectPoolItem
{
    public GameObject objectToPool;
    public int amountToPool;
    public bool shouldExpand = true;
}
1
2
3
4
5
6
7
8

然后，在ObjectPooler类中使用这个新类：

public class ObjectPooler : MonoBehaviour 
{
    public static ObjectPooler SharedInstance;
    
    //新增：用于存储不同类型游戏对象信息的列表
    public List<ObjectPoolItem> itemsToPool;

    //新增：用于存储所有已经实例化出来的游戏对象列表
    public List<GameObject> pooledObjects;

    void Awake()
    {
        SharedInstance = this;
    }

    void Start () 
    {
        pooledObjects = new List<GameObject>();
        
        foreach (ObjectPoolItem item in itemsToPool)
        {
            for (int i = 0; i < item.amountToPool; i++)
            {
                GameObject obj = (GameObject)Instantiate(item.objectToPool);
                obj.SetActive(false);
                pooledObjects.Add(obj);
            }
        }
    }

    public GameObject GetPooledObject(string tag)
    {
        for (int i=0; i<pooledObjects.Count; i++)
        {
            if (!pooledObjects[i].activeInHierarchy && pooledObjects[i].tag == tag)
            {
                return pooledObjects[i];
            }
        }

        foreach(ObjectPoolItem item in itemsTopool){
            if(item.objectTopool.tag == tag){
                if(item.shouldExpand){
                    GameObject obj=(GameObject)Instantiate(item.objectTopool);
                    obj.SetActive(false);
                    poolobjects.Add(obj);
                    return obj;
                }
            }
        }

        return null;
   }	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

在此版本中，你可以通过Unity编辑器为每种类型游戏对象指定预设、数量以及是否允许扩展。当需要获取一个特定标签(tag)的游戏对象时，只需调用GetPooledObject()函数并传入相应标签即可。

注意：请确保预设物体都有正确设置tag, 并且在使用完物体后记得把物体设为非激活状态以便再次使用。

Unity如何实现单例模式

在Unity中实现单例模式可以通过创建一个静态实例的脚本类来完成。这个类将始终返回同一个对象的引用，如果该对象没有被创建，那么它就会创建一个。

以下是在Unity中实现单例模式的一种常见方法：

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
    private static T _instance;

    public static T Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = FindObjectOfType<T>();
                if (_instance == null)
                {
                    GameObject singleton = new GameObject();
                    _instance = singleton.AddComponent<T>();
                    singleton.name = typeof(T).ToString() + " (Singleton)";
                    
                    // 确保单例不会被销毁
                    DontDestroyOnLoad(singleton);
                }
            }

            return _instance;
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

你可以通过继承这个Singleton类来创建自己的单例类。例如：

public class MySingletonClass : Singleton<MySingletonClass>
{
   // 这里是你自己的代码...
}
1
2
3
4
5

然后，你就可以通过MySingletonClass.Instance来访问这个单例对象了。

注意：虽然使用单例模式很方便，但也需要谨慎对待。过度使用可能导致代码难以理解和维护，并可能引发难以调试的问题。只有当你确信某个特定组件真正需要全局访问时，才应该使用此模式。

[MenuItem] 什么意思

在Unity中，[MenuItem]是一个特性(Attribute)，它用于在Unity的菜单栏中创建新的菜单项。这个特性可以应用于静态方法。

例如，你可能会使用以下代码来添加一个名为"Custom/My Function"的新菜单项：

using UnityEngine;
using UnityEditor;

public class MyEditorScript 
{
    [MenuItem("Custom/My Function")]
    static void MyFunction() 
    {
        // 这里是你自定义功能的代码...
        Debug.Log("My Function Was Called!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当你点击"Custom/My Function"这个菜单项时，就会执行MyFunction()方法，并在控制台打印出"My Function Was Called!"。

注意：因为[MenuItem]特性只能应用于静态方法，所以被标记为菜单项的函数必须是静态的。此外，这个特性只能用在编辑器脚本中，也就是说包含该函数的类必须放置在项目文件夹下名为 “Editor” 的文件夹内。

打包ab包出来后.manifest有什么作用

在Unity中，AssetBundle文件的".manifest"文件包含了一些关于AssetBundle的元数据，包括其依赖项和散列值。这些信息主要用于加载和缓存AssetBundles。

• 依赖项：
  当你从一个AssetBundle加载资源时，可能需要先加载其他的AssetBundles。这是因为资源可能引用了其他AssetBundles中的资源（例如材质、纹理等）。".manifest"文件会列出所有必须首先加载的依赖项。

• 散列值：
  散列值用于检查缓存中是否存在最新版本的AssetBundle。当你尝试从服务器下载一个已经在本地缓存过的AssetBundle时，Unity会比较本地版本和服务器上版本的散列值。如果两者相同，则Unity会直接从缓存中加载该bundle，而不是重新下载。

所以说，在处理.manifest文件时需要特别注意其作用和重要性。正确处理它们可以确保游戏正常运行，并有效利用玩家设备上的存储空间。

Image与RawImage的区别

在Unity的UI系统中，Image和RawImage都是用于显示图像的组件，但它们之间有一些关键区别：

Image：
这个组件使用Sprite作为其图像源。它支持各种类型的填充方法（例如简单填充、水平或垂直填充、径向360度等），可以使用九宫格布局来处理图像边缘，并且支持颜色渐变。此外，你还可以在Image上应用遮罩。

RawImage:
这个组件使用Texture作为其图像源。它不支持填充方法、九宫格布局或者遮罩等特性。但是，由于直接引用纹理数据，所以Raw Image更适合显示不需要以上特性，并且希望直接访问原始纹理数据的情况（例如WebCamTexture或者RenderTexture）。

总结
如果你需要更多控制和复杂的渲染选项(如颜色渐变, 填充, 遮罩等), 使用 Image. 如果你只是想简单地展示一个纹理并且不需要额外功能, 或者你正在处理不能转换为 Sprite 的纹理类型（例如WebCamTexture或RenderTexture）时，那么选择 Raw Image.

Unity有哪些特定的文件夹名字，有什么作用

在Unity项目中，有一些特定的文件夹名称具有特殊的含义和作用：

• Assets：这是所有Unity项目的根目录，所有的脚本、场景、预设、音频和图像等资源都应该放在这个文件夹或其子文件夹中。

• Editor：这个文件夹用于存放编辑器脚本，即那些只在Unity编辑器中运行并扩展其功能的脚本。例如自定义Inspector面板、菜单项等。

• Resources：你可以将需要使用到Resources.Load()方法动态加载的资源放入此文件夹。注意不要过度使用此类加载方式，因为它可能会增加应用程序启动时间，并使内存管理更复杂。

• StreamingAssets：这个目录下的所有内容都会被原封不动地拷贝到最终构建结果中。你可以用来存储如文本文件、数据库或者已经压缩好了格式无法再进行进一步优化处理的数据（比如视频）。

• Gizmos: 这个目录主要是用来存储自定义Gizmo图标，在Scene视图里面显示出来帮助开发者定位对象和理解场景布局。

• Plugins: 这个目录主要是用来存储插件，包括各种第三方库, 如Android .jar/.aar 文件, iOS静态库.a 文件等.

注意: 使用以上特殊名称创建新目录时，请确保大小写正确，并且直接将其创建在正确位置上。否则Unity可能无法识别该目录并提供相应功能。

Unity如何实现游戏截图

针对去屏幕截图
在Unity中，你可以使用ScreenCapture.CaptureScreenshot()方法来实现游戏截图。以下是一个简单的例子：

csharp
复制
using UnityEngine;

public class ScreenshotTaker : MonoBehaviour
{
public void TakeScreenshot()
{
// 生成文件名（以当前时间命名）
string fileName = “Screenshot_” + System.DateTime.Now.ToString(“yyyy-MM-dd_HH-mm-ss”) + “.png”;

    // 在游戏的数据路径下创建 Screenshots 文件夹（如果不存在）
    string directoryPath = Application.persistentDataPath + "/Screenshots/";
    if (!System.IO.Directory.Exists(directoryPath))
        System.IO.Directory.CreateDirectory(directoryPath);
    
    // 捕获屏幕并保存为 .png 文件
    ScreenCapture.CaptureScreenshot(directoryPath + fileName);
    
    Debug.Log("Screenshot saved to: " + directoryPath + fileName);
}
1
2
3
4
5
6
7
8
9
10

}
然后，你可以将这个脚本添加到场景中的任何GameObject上，并通过代码或者按钮点击等方式调用TakeScreenshot()方法。

注意：ScreenCapture.CaptureScreenshot()方法会在下一帧捕获屏幕，因此如果你立即查找文件可能不会找到它。

针对于特定摄像机或者区域进行截图
使用RenderTexture和Texture2D.ReadPixels()方法。
以下是一个简单的例子：

using UnityEngine;

public class CameraScreenshotTaker : MonoBehaviour
{
    public Camera screenshotCamera; // 截图用的摄像机

    public void TakeScreenshot(int width, int height)
    {
        // 创建一个新的RenderTexture
        RenderTexture renderTex = new RenderTexture(width, height, 24);
        
        // 让截图用的摄像机渲染到新建立的RenderTexture上
        screenshotCamera.targetTexture = renderTex;
        
        // 创建一个空纹理并读取屏幕内容到这个纹理中
        Texture2D screenShot = new Texture2D(width, height, TextureFormat.RGB24, false);
        
        screenshotCamera.Render();
        
        RenderTexture.active = renderTex;
        
        screenShot.ReadPixels(new Rect(0, 0, width,height), 0 ,0);
       
        screenShot.Apply();

        byte[] bytes=screenShot.EncodeToPNG();
        
        string filename=Application.dataPath + "/Screenshot.png";
        
        System.IO.File.WriteAllBytes(filename, bytes);

        Debug.Log(string.Format("截屏了一张照片: {0}", filename));
 
        // 恢复环境，释放申请的资源。
        screenshotCamera.targetTexture=null;
        RenderTexture.active=null; 
        GameObject.Destroy(renderTex);	
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

在这个脚本中，我们首先创建了一个新的RenderTexture对象，并将其设置为我们希望进行截图操作的摄像机目标纹理。然后，我们让该摄像机渲染一次，并使用ReadPixels()方法从当前激活（active）状态下得 RenderTexturereadPixels()读取所有像素信息。

之后就可以将这些数据保存为图片文件了。记住在完成所有操作后恢复环境并释放资源。

注意：以上代码只能在Unity主线程中运行，不能在另外线程中执行。

Unity如何调用android与iOS的 API函数

在Unity中调用Android和iOS的API，你需要使用Unity的插件功能。下面是一些基本步骤：

对于Android：

首先，你需要使用Java（或Kotlin）创建一个Android库（.jar或.aar文件），并在此库中定义你想要调用的函数。
然后，在Unity项目的Assets/Plugins/Android目录下放置这个库文件。
在C#脚本中，使用AndroidJavaObject 或 AndroidJavaClass来调用这个库里面的函数。
例如：

using UnityEngine;

public class AndroidPluginTest : MonoBehaviour
{
    void Start()
    {
        if (Application.platform == RuntimePlatform.Android)
        {
            AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
            AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");

            // Assuming the plugin class name is "com.example.myplugin.MyPlugin"
            // and it has a static method "foo"
            using (var pluginClass = new AndroidJavaClass("com.example.myplugin.MyPlugin"))
                pluginClass.CallStatic("foo", currentActivity);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

对于iOS：

你需要创建一个Objective-C（或Swift但会更复杂）类，并在其中定义你想要调用的函数。
将该类保存为.mm文件，并放入到Assets/Plugins/iOS目录下。
Unity将自动将这些类编译到生成的Xcode项目中。然后，在C#脚本中可以直接通过PInvoke机制来访问它们。
例如：

using System.Runtime.InteropServices;
using UnityEngine;

public class iOSPluginTest : MonoBehaviour
{
#if UNITY_IOS && !UNITY_EDITOR
    [DllImport("__Internal")]
    private static extern void _Foo();
#endif

    public void CallFoo()
    {
#if UNITY_IOS && !UNITY_EDITOR
        _Foo();
#endif
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

以上代码假设您有一个名为_Foo() 的Objective-C方法。

注意：确保当平台不匹配时正确处理平台相关代码，以防止在其他平台上产生编译错误。