Store variable value when reloading a Windows Form

I did the test, and it worked using a Static list and referencing all the buttons to button_Click , I also got all the controls of the form and saved them in a list where will I go and ask if it corresponds only  to the Tables , if they are Button and if they are in the list of occupied tables, I must clarify that until the application is closed to store the information but if it were to close for some reason it will no longer be possible to recover the information:

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private IEnumerable<Control> ListaControles;
    private List<Button> ListaOcupados;

    public class Class1<T>
    {
        public static List<T> ListaOcupados { get; set; }
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        ListaControles = obtenerControles(this, typeof(Button));
        ListaOcupados = new List<Button>();
        cargarListado();
    }

    private IEnumerable<Control> obtenerControles(Control control, Type tipo)
    {
        IEnumerable<Control> controles = control.Controls.Cast<Control>();
        return controles.SelectMany(x => obtenerControles(x, tipo))
                        .Concat(controles)
                        .Where(c => c.GetType() == tipo);
    }

    private void button_Click(object sender, EventArgs e)
    {
        if (!ListaOcupados.Any(x => x.Name == ((Button)sender).Name))
            ListaOcupados.Add((Button)sender);
        else
            ListaOcupados.RemoveAll(x => x.Name == ((Button)sender).Name);
        Class1<Button>.ListaOcupados = ListaOcupados;
        cargarListado();
    }

    private void cargarListado()
    {
        if (Class1<Button>.ListaOcupados != null)
        {
            if (Class1<Button>.ListaOcupados.Count > 0)
                ListaOcupados = Class1<Button>.ListaOcupados;
        }
        foreach (Control control in ListaControles)
        {
            if (control.GetType() == typeof(Button) && control.Text.Contains("Mesa"))
            {
                if (ListaOcupados.Any(x => x.Name == control.Name))
                    control.BackColor = Color.Red;
                else
                    control.BackColor = Color.Green;
            }
        }
    }
}

When storing the information in variables, when the app is closed for some reason, since they are not persisted, they will be lost. To persist data you have many options, from database to JSON, XML and txt files.

Going back to the question.

The safest thing is that you are not correctly implementing the concept of global variables.

I recommend you implement the singleton pattern, where you have a class which has a single instance and you could access that instance globally.

link

  

Applicability

     

Use when:

     

There should be exactly one instance of a class and this should be   accessible to customers from a known access point.

     

The single instance should be extensible by inheritance and the   customers should be able to use an extended instance without   modify your code.

public class MesasPresionadas
{
    private static MesasPresionadas data;

    private MesasPresionadas()
    {
    }

    public static MesasPresionadas Instance()
    {
        if (data == null)
            data = new MesasPresionadas(); 
        return data;
    }

    public bool presionado{ get; set; }
    public bool presionado2{ get; set; }
    public bool presionado3{ get; set; }
    public bool presionado4{ get; set; }
    public bool presionado5{ get; set; }
    public bool presionado6{ get; set; }
    public bool presionado7{ get; set; }
    public bool presionado8{ get; set; }
    public bool presionado9{ get; set; }
    public bool presionado10{ get; set; }
    public bool presionado11{ get; set; }
    public bool presionado12{ get; set; }
}

And the way to access the data from any point would be

if (MesasPresionadas.Instance().presionado  == false)
{
    button1.BackColor = Color.Gold;
    MesasPresionadas.Instance().presionado = true;
}
else
{
    button1.BackColor = Color.Green;
    MesasPresionadas.Instance().presionado  = false;
}

With the IsolatedStorageFile class you can create virtual files to which only your application will have access and will only be visible by it. You could use it to save information about the last state of your application and its variables. Take a look at this link where an example of use comes.

Edit: I usually use it to store information such as the name of the last user who accessed or even his password. The reading and writing in the file is like the one that is done with an ordinary file.

Edited 2:

using System;
using System.IO;
using System.IO.IsolatedStorage;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            IsolatedStorageFile isoStore = IsolatedStorageFile.GetStore(IsolatedStorageScope.User | IsolatedStorageScope.Assembly, null, null);

            if (isoStore.FileExists("TestStore.txt"))
            {
                Console.WriteLine("The file already exists!");
                using (IsolatedStorageFileStream isoStream = new IsolatedStorageFileStream("TestStore.txt", FileMode.Open, isoStore))
                {
                    using (StreamReader reader = new StreamReader(isoStream))
                    {
                        Console.WriteLine("Reading contents:");
                        Console.WriteLine(reader.ReadToEnd());
                    }
                }
            }
            else
            {
                using (IsolatedStorageFileStream isoStream = new IsolatedStorageFileStream("TestStore.txt", FileMode.CreateNew, isoStore))
                {
                    using (StreamWriter writer = new StreamWriter(isoStream))
                    {
                        writer.WriteLine("Hello Isolated Storage");
                        Console.WriteLine("You have written to the file.");
                    }
                }
            }   
        }
    }
}

I hope it serves you. Greetings.