我可以在没有项目设置的情况下在 c# 代码中#define 一个常量解决方案范围吗？

Question

我知道这被问了几次并回答了几次，例如 Solution-wide #define、Is There anyway to #define Constant on a Solution Basis? 和 How to define a constant globally in C# (like DEBUG)。

但就我而言，我不能使用任何建议的方法：

我正在为 UnityProjects（一种提供特定功能的包）编写不同的“模块”（或插件，如果你愿意的话）。这个想法是开发人员可以通过导入包含所有脚本和资源的UnityPackage 来加载某个“模块”以在他的项目中使用。

但其中一些模块本身依赖于其他模块。所以到目前为止我尝试的是在每个模块中都有一个类Constants，具有单独的命名空间和预处理器定义。

模块 A

#if !MODULE_A
#define MODULE_A   // BUT I WOULD NEED THIS GLOBAL NOT ONLY HERE
#endif

    namespace Module_A
    {
        public static class Constants
        {
            // some constants for this namespace here
        }
    }

模块 B

#if !MODULE_B
#define MODULE_B    // BUT I WOULD NEED THIS GLOBAL NOT ONLY HERE
#endif

#if !MODULE_A    // WILL BE NOT DEFINED OFCOURSE SINCE #define IS NOT GLOBAL
#error Module A missing!
#else

    namespace Module_B
    {
        public static class Constants
        {
            // some constants for this namespace here
        }

        // and other code that might require Module A
    }
#endif

当然，这不能像这样工作，因为#defines 不是全局的，而是仅在当前文件中。

问题

对于模块的整个想法和简单的“加载您的模块”，我不能要求用户首先更改项目或解决方案设置，例如由this answer 建议，但必须仅使用随 UnityPackage 导入的 (c#) 资源（至少以我目前的专业知识）。

有没有办法通过仅导入模块的 UnityPackage 以某种方式为整个 Unity-Project 设置/定义这些常量？

---

编辑：

我可以使用Assets/msc.rsp 在 Unity 中找到 1 定义的解决方案。但这仍然不适用于多个模块，因为它们必须写入同一个文件。

Answer 1

一般来说，我在 C# 中解决此问题的方法是定义所有模块都包含的通用接口集。我认为您可以通过将每个模块中的文件放在同一位置来使用 Unity 执行此操作，从而允许以后的安装覆盖这些相同的文件（显然，具有相同的内容）。然后，您将放置公开属性的编辑器控件以保存这些接口的实例，然后将它们连接到 UI 中。您将测试这些属性的值 null 以确定缺少哪些属性。

Common.cs：

public interface IModuleA {}
public interface IModuleB {}

模块A.cs

public class ModuleA : IModuleA {}

ModuleB.cs

public class ModuleB : IModuleB
{
    public IModuleA ModuleAInstance {get; set;}

    private bool IsModuleAPresent() 
    {
        return !ModuleAInstance == null;
    }
}

解决这个问题的理想方法是使用包管理器和适当的依赖注入，但使用 Unity 做到这一点并不简单。

Answer 2

经过大量搜索，我终于能够整理出一个非常简单的解决方案，我想与您分享：

---

InitializeOnLoad

Unity 有一个属性[InitializeOnLoad]。它告诉 Unity 尽快初始化相应的类

• Unity 启动
• 在重新编译脚本之后 => 在导入带有脚本的新 unitypackage 之后

---

静态构造函数

在他们的 Running Editor Code On Launch 示例中，他们展示了如何将其与 static 构造函数结合起来。

来自static-constructors：

在创建第一个实例或引用任何静态成员之前，会自动调用静态构造函数来初始化类。

虽然通常您仍然需要创建类的实例，但静态构造函数会在类初始化时立即“实例化/执行”，我们使用 [InitializeOnLoad] 属性强制执行此操作。

---

脚本定义符号

Further Unity 实际上有在PlayerSettings 中定义了项目范围。

好消息是：我们还可以通过脚本 API 访问它们：

• PlayerSettings.GetScriptingDefineSymbolsForGroup
• PlayerSettings.SetScriptingDefineSymbolsForGroup。

---

所以我现在做的是以下

模块 A

这个模块没有依赖，只是在 PlayerSettings 中定义了一个“全局定义”。我把这个脚本放在某个地方，例如在Assets/ModuleA/Editor 中（重要的是最后一个文件夹的名称）。

using System.Linq;
using UnityEditor;

namespace ModuleA
{
    // Will be initialized on load or recompiling
    [InitializeOnLoad]
    public static class Startup
    {
        // static constructor is called as soon as class is initialized
        static Startup()
        {
            #region Add Compiler Define

            // Get the current defines
            // returns a string like "DEFINE_1;DEFINE_2;DEFINE_3"
            var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
            // split into list just to check if my define is already there
            var define = defines.Split(';').ToList();

            if (!define.Contains("MODULE_A")
            {
                // if not there already add my define 
                defines += ";MODULE_A";
            }

            // and write back the new defines
            PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, defines);

            #endregion
        }
    }
}

模块 B

这个模块依赖于Module A。所以它本身定义了一个“全局定义”（因此以后的模块可以检查它们在Module B 上的依赖关系）但另外它首先检查是否导入了模块 A。如果缺少Module A，它将向调试控制台打印错误。

（您也可以使用#error SOME TEXT 引发编译器错误，但由于某种原因，这无法正确打印出 URL，所以我决定使用Debug.LogError）

我把这个脚本放在某个地方，例如在Assets/ModuleB/Editor

#if MODULE_A
using System.Linq;
#endif
using UnityEditor;
#if !MODULE_A
using UnityEngine;
#endif

namespace ModuleB
{
    // Will be initialized on load or recompiling
    [InitializeOnLoad]
    public static class Startup
    {
        // static constructor is called as soon as class is initialized
        static Startup()
        {
#if !MODULE_A
            Debug.LogErrorFormat("! Missing Module Dependency !" +
                                 "\nThe module {0} depends on the module {1}." +
                                 "\n\nDownload it from {2} \n",
                "MODULE_B",
                "MODULE_A",
                "https://Some.page.where./to.find.it/MyModules/ModuleA.unitypackage"
                );
#else
            // Add Compiler Define

            var defines = PlayerSettings.GetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup);
            var define = defines.Split(';').ToList();

            if (!define.Contains("MODULE_B"))
            {
                defines += ";MODULE_B";
            }

            PlayerSettings.SetScriptingDefineSymbolsForGroup(EditorUserBuildSettings.selectedBuildTargetGroup, defines);

#endif
        }
    }
}

---

所以稍后在 Module B 的其他脚本中，我有两个选项（两者的作用基本相同）

• 我可以到处查看 #if MODULE_A 以准确检查此脚本所依赖的模块

• 或者我可以改为检查#if MODULE_B，而不是检查一行是否满足所有依赖项，否则我不定义MODULE_B。

---

通过这种方式，我可以完全检查某些模块之间的所有依赖关系，这很棒。到目前为止，我看到的唯一两个缺陷是：

• 我们必须知道每个模块的定义（例如MODULE_A）是怎样的，如果将来更改它，也必须在所有依赖模块中进行更改
• 如果模块从项目中删除，“全局定义”不会被删除

但是很好 - 哪种解决方案是完美的？