Глобальные переменные c windows form

They have already answered how to use a global variable.

I will tell you why the use of global variables is a bad idea as a result of this question carried out in stackoverflow in Spanish.

Explicit translation of the text in Spanish:

Impact of the change

The problem with global variables is that they create hidden dependencies. When it comes to large applications, you yourself do not know / remember / you are clear about the objects you have and their relationships.

So, you can not have a clear notion of how many objects your global variable is using. And if you want to change something of the global variable, for example, the meaning of each of its possible values, or its type? How many classes or compilation units will that change affect? If the amount is small, it may be worth making the change. If the impact will be great, it may be worth looking for another solution.

But what is the impact? Because a global variable can be used anywhere in the code, it can be very difficult to measure it.

In addition, always try to have a variable with the shortest possible life time, so that the amount of code that makes use of that variable is the minimum possible, and thus better understand its purpose, and who modifies it.

A global variable lasts for the duration of the program, and therefore, anyone can use the variable, either to read it, or even worse, to change its value, making it more difficult to know what value the variable will have at any given program point. .

Order of destruction

Another problem is the order of destruction. Variables are always destroyed in reverse order of their creation, whether they are local or global / static variables (an exception is the primitive types, int,enums, etc., which are never destroyed if they are global / static until they end the program).

The problem is that it is difficult to know the order of construction of the global (or static) variables. In principle, it is indeterminate.

If all your global / static variables are in a single compilation unit (that is, you only have a .cpp), then the order of construction is the same as the writing one (that is, variables defined before, are built before).

But if you have more than one .cpp each with its own global / static variables, the global construction order is indeterminate. Of course, the order in each compilation unit (each .cpp) in particular, is respected: if the global variableA is defined before B,A will be built before B, but It is possible that between A andB variables of other .cpp are initialized. For example, if you have three units with the following global / static variables:

Image1

In the executable it could be created in this order (or in any other order as long as the relative order is respected within each .cpp):

Image2

Why is this important? Because if there are relations between different static global objects, for example, that some use others in their destructors, perhaps, in the destructor of a global variable, you use another global object from another compilation unit that turns out to be already destroyed ( have been built later).

Hidden dependencies and * test cases *

I tried to find the source that I will use in this example, but I can not find it (anyway, it was to exemplify the use of singletons, although the example is applicable to global and static variables). Hidden dependencies also create new problems related to controlling the behavior of an object, if it depends on the state of a global variable.

Imagine you have a payment system, and you want to test it to see how it works, since you need to make changes, and the code is from another person (or yours, but from a few years ago). You open a new main, and you call the corresponding function of your global object that provides a bank payment service with a card, and it turns out that you enter your data and they charge you. How, in a simple test, have I used a production version? How can I do a simple payment test?

After asking other co-workers, it turns out that you have to «mark true», a global bool that indicates whether we are in test mode or not, before beginning the collection process. Your object that provides the payment service depends on another object that provides the mode of payment, and that dependency occurs in an invisible way for the programmer.

In other words, the global variables (or singletones), make it impossible to pass to «test mode», since global variables can not be replaced by «testing» instances (unless you modify the code where said code is created or defined). global variable, but we assume that the tests are done without modifying the mother code).

Solution

This is solved by means of what is called * dependency injection *, which consists in passing as a parameter all the dependencies that an object needs in its constructor or in the corresponding method. In this way, the programmer ** sees ** what has to happen to him, since he has to write it in code, making the developers gain a lot of time.

If there are too many global objects, and there are too many parameters in the functions that need them, you can always group your «global objects» into a class, style * factory *, that builds and returns the instance of the «global object» (simulated) that you want , passing the factory as a parameter to the objects that need the global object as dependence.

If you pass to test mode, you can always create a testing factory (which returns different versions of the same objects), and pass it as a parameter without having to modify the target class.

But is it always bad?

Not necessarily, there may be good uses for global variables. For example, constant values ​​(the PI value). Being a constant value, there is no risk of not knowing its value at a given point in the program by any type of modification from another module. In addition, constant values ​​tend to be primitive and are unlikely to change their definition.

It is more convenient, in this case, to use global variables to avoid having to pass the variables as parameters, simplifying the signatures of the functions.

Another can be non-intrusive «global» services, such as a logging class (saving what happens in a file, which is usually optional and configurable in a program, and therefore does not affect the application’s nuclear behavior), or std :: cout,std :: cin or std :: cerr, which are also global objects.

Any other thing, even if its life time coincides almost with that of the program, always pass it as a parameter. Even the variable could be global in a module, only in it without any other having access, but that, in any case, the dependencies are always present as parameters.

Answer by: Peregring-lk

Одним из ключевых аспектов разработки приложений на платформе .NET является использование форм Windows (WinForms). Эти формы предоставляют удобный интерфейс для взаимодействия с пользователем и позволяют создавать разнообразные приложения — от простых десктопных приложений до сложных корпоративных систем.

Одной из часто задаваемых вопросов при работе с WinForms является вопрос о создании глобальных переменных. Глобальная переменная — это переменная, которая доступна из любой части программы и может быть использована в любом месте.

В этой статье мы рассмотрим, как создать глобальную переменную в WinForms, а также обсудим некоторые важные моменты, связанные с использованием глобальных переменных.

Почему нужно создавать глобальные переменные?

Перед тем, как перейти к созданию глобальных переменных в WinForms, давайте рассмотрим, почему мы это делаем.

Как правило, глобальные переменные используются для хранения данных, которые должны быть доступны в разных частях программы. Например, если у нас есть переменная, которая содержит информацию о текущем пользователе, мы можем использовать глобальную переменную для сохранения этой информации и обращаться к ней из любой части программы.

Кроме того, глобальные переменные позволяют избежать дублирования кода. Вместо того, чтобы объявлять одну и ту же переменную в разных местах программы, мы можем объявить ее только один раз и использовать ее везде, где это необходимо.

Как создать глобальную переменную в WinForms?

Создание глобальной переменной в WinForms — это достаточно простой процесс. Нам нужно объявить переменную в классе формы и задать ей модификатор доступа public.

Вот пример:

public partial class Form1 : Form
{
public int globalVariable;

public Form1()
{
InitializeComponent();
}
}

В этом примере мы создаем класс Form1, который наследуется от класса Form. Мы также объявляем глобальную переменную globalVariable типа int.

Для того чтобы эта переменная была доступна из других классов и форм, мы устанавливаем ее модификатор доступа public. Теперь мы можем получить доступ к этой переменной из любой части программы.

Некоторые часто задаваемые вопросы

1. Можно ли использовать глобальные переменные в многопоточном приложении?

Да, можно. Но необходимо учитывать, что глобальные переменные в многопоточном приложении могут быть доступны для изменения одновременно из нескольких потоков. Это может привести к проблемам синхронизации и потенциальным ошибкам. Поэтому при использовании глобальных переменных в многопоточном приложении необходимо соблюдать правила безопасности потоков.

2. Какие другие способы хранения данных можно использовать в WinForms?

В WinForms существует множество способов хранения данных. Например, мы можем использовать базы данных, файлы конфигураций, реестр Windows или файлы. Какой способ выбирать зависит от требований конкретного приложения и задач, которые он решает.

3. Как использовать глобальную переменную из другого класса?

Чтобы использовать глобальную переменную из другого класса, необходимо сначала создать экземпляр класса, в котором эта переменная объявлена. Затем мы можем обращаться к этой переменной через экземпляр класса. Вот пример:

public partial class Form1 : Form
{
public int globalVariable;

public void SomeMethod()
{
Form2 form2 = new Form2();
form2.globalVariable = globalVariable;
}
}

В этом примере мы создаем экземпляр класса Form2 и устанавливаем его глобальную переменную globalVariable равной глобальной переменной globalVariable класса Form1.

Заключение

Глобальные переменные являются очень полезным инструментом при разработке приложений на платформе .NET. Они позволяют хранить данные, которые должны быть доступны в разных частях программы, избежать дублирования кода и упростить процесс программирования. Однако при использовании глобальных переменных необходимо учитывать их потенциальные проблемы и соблюдать правила безопасности потоков.