I am fairly new to plugin development. Only reading other plugin codes to understand them better. I compiled a plugin in Visual Studio 2022

Getting error this 

Code:

using Facepunch.Extend;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Oxide.Core;
using Oxide.Core.Configuration;
using Oxide.Core.Logging;
using Oxide.Core.Plugins;
using System.Runtime.CompilerServices;
using static Oxide.Plugins.BetterCash;

namespace Oxide.Plugins
{
    [Info("BetterCash", "Ifte", "1.0")]
    public class BetterCash : RustPlugin
    {
        [PluginReference]
        private Plugin Economics;

        private Configuration config;

        private class Configuration : SerializableConfiguration
        {
            [JsonProperty("General Settings")]
            public GeneralSettings generalSettings = new GeneralSettings();
            [JsonProperty("ATM Machine Settings")]
            public ATMMachineSettings aTMMachineSettings = new ATMMachineSettings();
        }

        public class GeneralSettings
        {
            public bool useBetterCash = true;
        }
        public class ATMMachineSettings
        {
            public bool atmMatchineEnabled = true;
            public int startingAmountForNewPlayers = 100;
        }
        //config
        protected override void LoadDefaultConfig() => config = new Configuration();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<Configuration>();
                if (config == null)
                {
                    throw new JsonException();
                }
            }
            catch
            {
                LoadDefaultConfig();
            }
        }

        protected override void SaveConfig()
        {
            Config.WriteObject(config, true);
        }

        //data for starting balances
        private PlayerData playerData;
        private DynamicConfigFile data;
        private bool dataChanged;
        public class PlayerData
        {
            public readonly Dictionary<string, double> Bank = new Dictionary<string, double>();
        }

        private void SavePlayerData()
        {
            if (dataChanged)
            {
                Puts("Saving BetterCash...");
                Interface.Oxide.DataFileSystem.WriteObject(Name, playerData);
            }
        }
        private void onServerSave()
        {
            SavePlayerData();
        }
        private void Unload()
        {
            SavePlayerData();
        }

        private void Init()
        {
            data = Interface.Oxide.DataFileSystem.GetFile(Name);
            try
            {
                Dictionary<ulong, double> temp = data.ReadObject<Dictionary<ulong, double>>();
                try
                {
                    playerData = new PlayerData();
                    foreach(KeyValuePair<ulong, double> old in temp)
                    {
                        if (!playerData.Bank.ContainsKey(old.Key.ToString()))
                        {
                            playerData.Bank.Add(old.Key.ToString(), old.Value);
                        }
                    }
                    dataChanged = true;
                }
                catch
                {
                    //ignores
                }
            }
            catch
            {
                playerData = data.ReadObject<PlayerData>();
                dataChanged = true;
            }
        }

        private void OnNewSave()
        {
            playerData.Bank.Clear();
            dataChanged = true;
        }


        //Json shits
        internal class SerializableConfiguration
        {
            public  string  ToJson() => JsonConvert.SerializeObject(this);

            public Dictionary<string, object> ToDictionary() => JsonHelper.Deserialize(ToJson()) as Dictionary<string, object>;

        }
        private static class JsonHelper
        {
            public static object Deserialize(string json) => ToObject(JToken.Parse(json));

            private static object ToObject(JToken token)
            {
                switch (token.Type)
                {
                    case JTokenType.Object:
                        return token.Children<JProperty>().ToDictionary(prop => prop.Name, prop => ToObject(prop.Value));
                    case JTokenType.Array:
                        return token.Select(ToObject).ToList();

                    default:
                        return ((JValue)token).Value;
                }
            }
        }
        //langs messages
        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["noPerm"] = "You lack the Permission to do this ",
            }, this);
        }



        //Starts

        //Economy Starts
        void Loaded()
        {
            if (Economics == null)
            {
                PrintError("Economics Not Detected, It is required for this plugin");
            }
        }





    }
}

I am getting this error on Dictionary i think, but when i type Dictionary<> it should use "using System.Collections.Generic;" But somehow it never used that when i type Dictionary<>



Any solution for this? I am new at this and recently learned C# and read all codes from Umod Basic API and a few plugins

Try adding the using directive using System.Collections.Generic; like suggested since Dictionary is part of it.

Thanks fixed with your solution :)