C# 输入类型或命名空间名称'；不支持例外'；找不到（是否缺少using指令或程序集引用？）

找不到类型或命名空间名称“NotSupportedException”（是否缺少using指令或程序集引用？） 错误仅在尝试编译时在unity中发生。在visual studio中不显示错误消息 我试图寻找解决方案，但没有任何效果，有人能帮我解决这个问题吗？ 如何解决

错误Assets\HeroEditor4D\Common\EditorScript\CharacterEditor.cs（141,23）：错误CS0246:找不到类型或命名空间名称“NotSupportedException”（是否缺少using指令或程序集引用？）

-

使用Assets.HeroEditor4D.Common.CharacterScripts；
使用HeroEditor.Common；
使用UnityEngine；
命名空间资产.HeroEditor4D.Common.EditorScript
{
/// 
///角色编辑器UI和行为。
/// 
公共类CharacterEditor:CharacterEditorBase
{
[标题（“其他”）]
公共布尔值UseEditorColorField=true；
公用字符串文件夹；
公共字符串TestRoomSceneName；
私有静态字符_temp；
/// 
///在应用程序启动时自动调用。
/// 
公共图书馆
{
RestoreTempCharacter（）；
}
public void OnValidate（）
{
if（字符==null）
{
Character=FindObjectOfType（）；
}
}
/// 
///移除所有设备。
/// 
公共无效重置（）
{
Character.Parts.ForEach（i=>i.ResetEquipment（））；
初始化的dropdowns（）；
}
#如果统一编辑器
/// 
///保存要预制的角色。
/// 
公共作废保存（）
{
PrefactFolder=UnityEdit.EditorUtility.SaveFilePanel（“保存字符预制”，PrefactFolder，“新字符”，“预制”）；
如果（文件夹长度>0）
{
保存（“资产”+文件夹.Replace（Application.dataPath，null））；
}
}
/// 
///从预置加载字符。
/// 
公共空荷载（）
{
PrefactFolder=UnityEdit.EditorUtility.OpenFilePanel（“加载字符预制”，PrefactFolder，“预制”）；
如果（文件夹长度>0）
{
加载（“资产”+文件夹.Replace（Application.dataPath，null））；
}
//特征提示（）；
}
/// 
///将字符保存到json。
/// 
public void SaveToJson（）
{
PrefactFolder=UnityEdit.EditorUtility.SaveFilePanel（“将字符保存到json”，PrefactFolder，“新字符”，“json”）；
如果（文件夹长度>0）
{
var path=“Assets”+文件夹.Replace（Application.dataPath，null）；
var json=Character.ToJson（）；
System.IO.File.WriteAllText（路径，json）；
LogFormat（“Json保存到{0}:{1}”，路径，Json）；
}
//特征提示（）；
}
/// 
///从json加载字符。
/// 
公共void LoadFromJson（）
{
PrefactFolder=UnityEdit.EditorUtility.OpenFilePanel（“从json加载字符”，PrefactFolder，“json”）；
如果（文件夹长度>0）
{
var path=“Assets”+文件夹.Replace（Application.dataPath，null）；
var json=System.IO.File.ReadAllText（路径）；
Character.LoadFromJson（json）；
}
//特征提示（）；
}
公共覆盖无效保存（字符串路径）
{
Character.transform.localScale=Vector3.1；
#如果UNITY\u 2018\u 3\u或更新
UnityEdit.PrefactUtility.SaveAsPrefabAsset（Character.gameObject，path）；
#否则
UnityEditor.prefableUtility.createPrefable（路径、角色、游戏对象）；
#恩迪夫
LogFormat（“预置保存为{0}”，路径）；
}
公共覆盖无效加载（字符串路径）
{
var character=UnityEdit.AssetDatabase.LoadAssetPath（路径）；
//Character.GetComponent（）.firemarm.Params=Character.firemarm.Params；//TODO:解决方法
加载（字符）；
//FindObjectOfType（）.OnCharacterLoaded（字符）；
}
#否则
公共覆盖无效保存（字符串路径）
{
抛出新的NotSupportedException（）；
}
公共覆盖无效加载（字符串路径）
{
抛出新的NotSupportedException（）；
}
#恩迪夫
/// 
///使用演示设置测试角色。
/// 
公开无效测试（）
{
//#如果统一编辑器
//if（UnityEditor.EditorBuildSettings.scenes.All（i=>！i.path.Contains（TestRoomSceneName）））
//{
//UnityEdit.EditorUtility.DisplayDialog（“HeroView编辑器”，string.Format（“请将“{0}.scene”添加到构建设置中！”，TestRoomSceneName），“确定”）；
//返回；
//}
//#恩迪夫
//var controller=Character.gameObject.AddComponent（）；
//controller.center=新矢量3（0,1.125f）；
//控制器高度=2.5f；
//控制器半径=0.75f；
//Character.GetComponent（）.enabled=true；
//Character.gameObject.AddComponent（）；
//DontDestroyOnLoad（字符）；
//_temp=字符作为字符；
//加载场景（TestRoomSceneName）；
//特征提示（）；
}
受保护的覆盖无效OpenPalette（游戏对象调色板，选定颜色）
{
#如果统一党获胜
如果（使用编辑或颜色字段）
{
EditorColorField.Open（选中）；
}
其他的
#恩迪夫
{
    #else

    public override void Save(string path)
    {
        throw new NotSupportedException();
    }

    public override void Load(string path)
    {
LINE ERROR        throw new NotSupportedException();
    }

    #endif

using Assets.HeroEditor4D.Common.CharacterScripts;
using HeroEditor.Common;
using UnityEngine;

namespace Assets.HeroEditor4D.Common.EditorScripts
{
    /// <summary>
    /// Character editor UI and behaviour.
    /// </summary>
    public class CharacterEditor : CharacterEditorBase
    {
        [Header("Other")]
        public bool UseEditorColorField = true;
        public string PrefabFolder;
        public string TestRoomSceneName;

        private static Character _temp;

        /// <summary>
        /// Called automatically on app start.
        /// </summary>
        public void Awake()
        {
            RestoreTempCharacter();
        }

        public void OnValidate()
        {
            if (Character == null)
            {
                Character = FindObjectOfType<Character4D>();
            }
        }

        /// <summary>
        /// Remove all equipment.
        /// </summary>
        public void Reset()
        {
            Character.Parts.ForEach(i => i.ResetEquipment());
            InitializeDropdowns();
        }

        #if UNITY_EDITOR

        /// <summary>
        /// Save character to prefab.
        /// </summary>
        public void Save()
        {
            PrefabFolder = UnityEditor.EditorUtility.SaveFilePanel("Save character prefab", PrefabFolder, "New character", "prefab");

            if (PrefabFolder.Length > 0)
            {
                Save("Assets" + PrefabFolder.Replace(Application.dataPath, null));
            }
        }

        /// <summary>
        /// Load character from prefab.
        /// </summary>
        public void Load()
        {
            PrefabFolder = UnityEditor.EditorUtility.OpenFilePanel("Load character prefab", PrefabFolder, "prefab");

            if (PrefabFolder.Length > 0)
            {
                Load("Assets" + PrefabFolder.Replace(Application.dataPath, null));
            }

            //FeatureTip();
        }

        /// <summary>
        /// Save character to json.
        /// </summary>
        public void SaveToJson()
        {
            PrefabFolder = UnityEditor.EditorUtility.SaveFilePanel("Save character to json", PrefabFolder, "New character", "json");

            if (PrefabFolder.Length > 0)
            {
                var path = "Assets" + PrefabFolder.Replace(Application.dataPath, null);
                var json = Character.ToJson();

                System.IO.File.WriteAllText(path, json);
                Debug.LogFormat("Json saved to {0}: {1}", path, json);
            }

            //FeatureTip();
        }

        /// <summary>
        /// Load character from json.
        /// </summary>
        public void LoadFromJson()
        {
            PrefabFolder = UnityEditor.EditorUtility.OpenFilePanel("Load character from json", PrefabFolder, "json");

            if (PrefabFolder.Length > 0)
            {
                var path = "Assets" + PrefabFolder.Replace(Application.dataPath, null);
                var json = System.IO.File.ReadAllText(path);

                Character.LoadFromJson(json);
            }

            //FeatureTip();
        }

        public override void Save(string path)
        {
            Character.transform.localScale = Vector3.one;

            #if UNITY_2018_3_OR_NEWER

            UnityEditor.PrefabUtility.SaveAsPrefabAsset(Character.gameObject, path);

            #else

            UnityEditor.PrefabUtility.CreatePrefab(path, Character.gameObject);

            #endif

            Debug.LogFormat("Prefab saved as {0}", path);
        }

        public override void Load(string path)
        {
            var character = UnityEditor.AssetDatabase.LoadAssetAtPath<Character4D>(path);

            //Character.GetComponent<Character>().Firearm.Params = character.Firearm.Params; // TODO: Workaround
            Load(character);
            //FindObjectOfType<CharacterBodySculptor>().OnCharacterLoaded(character);
        }

        #else

        public override void Save(string path)
        {
            throw new NotSupportedException();
        }

        public override void Load(string path)
        {
            throw new NotSupportedException();
        }

        #endif

        /// <summary>
        /// Test character with demo setup.
        /// </summary>
        public void Test()
        {
            //#if UNITY_EDITOR

            //if (UnityEditor.EditorBuildSettings.scenes.All(i => !i.path.Contains(TestRoomSceneName)))
            //{
            //  UnityEditor.EditorUtility.DisplayDialog("HeroView Editor", string.Format("Please add '{0}.scene' to Build Settings!", TestRoomSceneName), "OK");
            //  return;
            //}

            //#endif

            //var controller = Character.gameObject.AddComponent<CharacterController>();

            //controller.center = new Vector3(0, 1.125f);
            //controller.height = 2.5f;
            //controller.radius = 0.75f;
            //Character.GetComponent<WeaponControls>().enabled = true;
            //Character.gameObject.AddComponent<CharacterControl>();
            //DontDestroyOnLoad(Character);
            //_temp = Character as Character;
            //SceneManager.LoadScene(TestRoomSceneName);

            //FeatureTip();
        }

        protected override void OpenPalette(GameObject palette, Color selected)
        {
            #if UNITY_EDITOR_WIN

            if (UseEditorColorField)
            {
                EditorColorField.Open(selected);
            }
            else

            #endif

            {
                Editor.SetActive(false);
                palette.SetActive(true);
            }
        }

        private void RestoreTempCharacter()
        {
            //if (_temp == null) return;

            //Character.GetComponent<Character>().Firearm.Params = _temp.Firearm.Params; // TODO: Workaround
            //Load(_temp);
            //FindObjectOfType<CharacterBodySculptor>().OnCharacterLoaded(_temp);
            //Destroy(_temp.gameObject);
            //_temp = null;
        }

        protected override void FeedbackTip()
        {
            #if UNITY_EDITOR

            var success = UnityEditor.EditorUtility.DisplayDialog("HeroView Editor", "Hi! Thank you for using my asset! I hope you enjoy making your game with it. The only thing I would ask you to do is to leave a review on the Asset Store. It would be awasome support for my asset, thanks!", "Review", "Later");

            RequestFeedbackResult(success, false);

            #endif
        }

        private void FeatureTip()
        {
            #if UNITY_EDITOR

            if (UnityEditor.EditorUtility.DisplayDialog("HeroView Editor", "This feature is available only in PRO asset version!", "Navigate", "Cancel"))
            {
                Application.OpenURL(LinkToProVersion);
            }

            #endif
        }
    }
}

using System;