There are a number  of ways.

The "easiest" is.. To use a "global" variable... Defing the variable  in the
definitions part  of a module  as public.
Public variable are generally "frowned upon" though.

How are your userforms set up? Do you have mre than one? What are you
actually trying to do?

You could put the code  you want in a subroutine in Module1 and then call  it
depending on the option chosen in the events that happen when closing the
form... Efectively moving what happens to be triggered before the form
actually black holes.

If you want to show excepts of code, then you need to provide ALL the
pertinent information. E.g. where and how are these variables defined?
What is their scope?

I suspect you need to show the whole module(s). If it's too long, then you
probably should be cutting back to something shorter and simpler for your
testing anyway.

Also. Please modernise your Basic. You shouldn't be using labels. You
should really be using "If ... Then ... EndIf".

Lastly. Please ensure that you have Option Explicit at the top of each
module.

Somehow I knew you'd ding me for not explicitly showing Option
Explicit. ;) So I rewrote new code  to create  a simple test, and
I'll list  all the code here.
Note: I went back to Walkenbach's VBA Power Programming book for
general code reference here to ensure I was doing it correctly.

I created a simple UserForm with two option buttons  titled Yes and
No, and added OK and Cancel buttons. The Yes makes variable  x = 1,
and the No makes x = 2.

Two Msgbox'es show the value at specific points in the code. The
Msgbox in the UserForm module shows  the right value, but in Module1
it shows a 0 as the variable doesn't carry over.

This code is from the Command Button on Sheet1 called Variable Test,
and resides in Microsoft Excel Objects -> Sheet1(Sheet1):
'------------------------------
Private Sub CommandButton1_Click()
UserForm1.Show
End Sub
'------------------------------

This code is in Forms -> UserForm1:
'------------------------------
Option Explicit
Public x As Integer

Private Sub OK_Button_Click()
If Yes_Button Then x = 1
If No_Button Then x = 2
MsgBox (x)
Call Var_Test
End Sub

Private Sub Cancel_Button_Click()
Unload UserForm1
End Sub
'------------------------------

And this code is in Module1:
'------------------------------
Option Explicit
Public x As Integer

Sub Var_Test()
MsgBox (x)
Unload UserForm1
End Sub
'------------------------------

It all works without an error, except that the variable x is correct
in the UserForm module  and then goes to 0 in the Module1 module.

You are declaring x twice. Do not declare it in the userform  - that makes 2
x's and the userform is only operating on its own x. If you take the Public
x As Integer out of the userform it will work.

But, seriously ... it's so very important to have it on. Excel will insert
them for you. In the VB environment: Tools/Options/Editor/"Require Variable
Declaration" should be ticked.

The two "Public x" define different variables, not references to the same
one.

Leave the one in UserForm1 as it is. Remove the one from Module1.

A compile will now give you an error because x is not defined  in Module1.
This is correct  and shows  you that Option Explicit is doing its job.

Now, use "dot" notation in Module1 to access the x in UserForm1:

MsgBox (UserForm1.x)

I seem to be in the minority here, but I really don't like this
solution. Pass the variable  to the sub. Then, any form or module
can use the sub not just this one form and this one variable. There
is also no problem with changing the name of x and missing the
reference to it in the module. The sub code  is more robust and the
code is more maintainable.



:: This code is in Forms -> UserForm1:
:: '------------------------------
:: Option Explicit
:: Public x As Integer
::
:: Private Sub OK_Button_Click()
:: If Yes_Button Then x = 1
:: If No_Button Then x = 2
:: MsgBox (x)
:: Call Var_Test

Call Var_Test(x)


:: End Sub
::
:: Private Sub Cancel_Button_Click()
:: Unload UserForm1
:: End Sub
:: '------------------------------
::
:: And this code is in Module1:
:: '------------------------------
:: Option Explicit
:: Public x As Integer

Delete the line  above.


:: Sub Var_Test()

Sub Var_Test(x as Integer)

:: MsgBox (x)
:: Unload UserForm1
:: End Sub

> I seem to be in the minority here, but I really don't like this
> solution. Pass the variable  to the sub. Then, any form or module
> can use the sub not just this one form and this one variable. There
> is also no problem with changing the name of x and missing the
> reference to it in the module. The sub code  is more robust and the
> code is more maintainable.

Actually I didn't write any of it - just for the record. :-)

You are probably right, but that wasn't the question. The question  was
about how to use a global variable.

On occasions, I use global variables. They have their uses. Most of the
time I don't need them.

> ... There is also no problem with changing the name of x and missing the
> reference to it in the module.

Well, that's what compilers are for. If you change the name of x, then the
compiler will object.

Another problem with this test code is that it unloads the test form from
within the called subroutine - bad practice. But it is only a quick test
program, after all.