Clases de unica instancia:

```c#
    public class Opciones
    {
        public enum LLM_a_Usar
        {
            OpenAI,
            Ollama,
            Groq
        }
        public enum modoDeUso
        {
            Corregir,
            Chat,
        }

        public Dictionary<LLM_a_Usar, string> nombreLLM = new Dictionary<LLM_a_Usar, string>
        {
        { Opciones.LLM_a_Usar.Ollama, "Ollama" },
        { Opciones.LLM_a_Usar.Groq, "Groq" },
        { Opciones.LLM_a_Usar.OpenAI, "OpenAI" },        
 
        };

        private static Opciones _instance;
        
        public static Opciones Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new Opciones();
                    _instance.LLM = LLM_a_Usar.OpenAI;
                    _instance.modo = modoDeUso.Corregir;
                }
                return _instance;
            }
        }

        public LLM_a_Usar LLM { get; set; }
        public modoDeUso modo { get; set; }

        public string nombreDeLLM() {
            return nombreLLM[LLM];
        }

        private Opciones() { }
    }
```


Otro ejemplo:

```c#
 internal class EstadoPersistente
 {
     // Ruta donde se guardará el estado
     private static readonly string _filePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "estado.json");

     // Instancia privada estática, parte del patrón Singleton
     private static EstadoPersistente _instance;

     // Propiedad privada para el directorio de trabajo
     private string _strDirectorioTrabajo;

     // Propiedad pública con get y set para controlar el acceso a _strDirectorioTrabajo
     public string directorio
     {
         get { return _strDirectorioTrabajo; }
         set { _strDirectorioTrabajo = value; }
     }

     // Constructor privado para evitar la instanciación externa
     private EstadoPersistente()
     {
         _strDirectorioTrabajo = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
     }

     // Propiedad pública estática para acceder a la instancia
     public static EstadoPersistente Instance
     {
         get
         {
             if (_instance == null)
             {
                 _instance = CargarEstado();
             }
             return _instance;
         }
     }

     // Método para guardar el estado en un archivo JSON
     public void GuardarEstado()
     {
         string json = JsonConvert.SerializeObject(this);
         File.WriteAllText(_filePath, json);
     }

     // Método estático para cargar el estado desde un archivo JSON
     private static EstadoPersistente CargarEstado()
     {
         if (File.Exists(_filePath))
         {
             string json = File.ReadAllText(_filePath);
             return JsonConvert.DeserializeObject<EstadoPersistente>(json);
         }
         return new EstadoPersistente(); // Devuelve una nueva instancia si no existe el archivo
     }
 }
```