How to Access Environment Variables in VisualCOBOL

Micro Focus has long used environment variables in their products to define execution requirements, locate modules and enable runtime behavior. With the release of VisualCOBOL and a fully managed .NET environment, how does one enable the comparable functionality? .NET provides the answer with the "System.Environment" class.

The purpose of this article is to provide the reader with an example of how to read and set environment variables from within a managed COBOL environment. We will utilize a WinForm to provide our user interaction. The form has already been created utilizing standard labels, textboxes and a command button. The user can review the Visual COBOL documentation for an explanation of how to create the WinForm.



Let's start by reviewing the System.Environment class within .NET.

System.Environment

The System.Environment class in .NET is used to retrieve information such as command-line arguments, the exit code, environment variable settings, the version of the operating system and other relevant piece of information about the environment in which the task is running in.
From the MSDN documentation the following properties are available within the class:

Name	Description
CommandLine	Gets the command line for this process.
CurrentDirectory	Gets or sets the fully qualified path of the current working directory.
ExitCode	Gets or sets the exit code of the process.
HasShutdownStarted	Gets a value indicating whether the common language runtime (CLR) is shutting down.
Is64BitOperatingSystem	Determines whether the current operating system is a 64-bit operating system.
Is64BitProcess	Determines whether the current process is a 64-bit process.
MachineName	Gets the NetBIOS name of this local computer.
NewLine	Gets the newline string defined for this environment.
OSVersion	Gets an OperatingSystem object that contains the current platform identifier and version number.
ProcessorCount	Gets the number of processors on the current machine.
StackTrace	Gets current stack trace information.
SystemDirectory	Gets the fully qualified path of the system directory.
SystemPageSize	Gets the amount of memory for an operating system's page file.
TickCount	Gets the number of milliseconds elapsed since the system started.
UserDomainName	Gets the network domain name associated with the current user.
UserInteractive	Gets a value indicating whether the current process is running in user interactive mode.
UserName	Gets the user name of the person who is currently logged on to the Windows operating system.
Version	Gets a Version object that describes the major, minor, build, and revision numbers of the common language runtime.
WorkingSet	Gets the amount of physical memory mapped to the process context.

As you can see there is quite a bit of information that one can obtain using the class. But we're interested in how to either set or retrieve environment variables. The following table, again from the MSDN documentation, describes the methods available:

Name	Description
Exit	Terminates this process and gives the underlying operating system the specified exit code.
ExpandEnvironmentVariables	Replaces the name of each environment variable embedded in the specified string with the string equivalent of the value of the variable, then returns the resulting string.
FailFast(String)	Immediately terminates a process after writing a message to the Windows Application event log, and then includes the message in error reporting to Microsoft.
FailFast(String, Exception)	Immediately terminates a process after writing a message to the Windows Application event log, and then includes the message and exception information in error reporting to Microsoft.
GetCommandLineArgs	Returns a string array containing the command-line arguments for the current process.
GetEnvironmentVariable(String)	Retrieves the value of an environment variable from the current process.
GetEnvironmentVariable(String, EnvironmentVariableTarget)	Retrieves the value of an environment variable from the current process or from the Windows operating system registry key for the current user or local machine.
GetEnvironmentVariables()	Retrieves all environment variable names and their values from the current process.
GetEnvironmentVariables(EnvironmentVariableTarget)	Retrieves all environment variable names and their values from the current process, or from the Windows operating system registry key for the current user or local machine.
GetFolderPath(Environment.SpecialFolder)	Gets the path to the system special folder that is identified by the specified enumeration.
GetFolderPath(Environment.SpecialFolder, Environment.SpecialFolderOption)	Gets the path to the system special folder that is identified by the specified enumeration, and uses a specified option for accessing special folders.
GetLogicalDrives	Returns an array of string containing the names of the logical drives on the current computer.
SetEnvironmentVariable(String, String)	Creates, modifies, or deletes an environment variable stored in the current process.
SetEnvironmentVariable(String, String, EnvironmentVariableTarget)	Creates, modifies, or deletes an environment variable stored in the current process or in the Windows operating system registry key reserved for the current user or local machine.

The methods we're interested in are GetEnvironmentalVariable and SetEnvironmentVariable. Let's look at how these are coded up!

Retrieving Environment Variables

The button_click event of the Go button is what begins execution of the process. From the figure at the beginning of the article we've established two areas, a get and a set area. In the Get area we want to retrieve three environment variables, the execution path or 'PATH'; the location of the install directory for Windows or 'WinDir'; and the operating system that is running our application or 'OS'. We will place the value returned for each environment variable into the text property of a textbox we've established for each. The code to accomplish this is:



The basic format for retrieving environment variables is

Set something to type Environment::GetEnvironmentVariable(variable name)

Where 'something' is a string defined variable. The 'magic' is available due to the keyword 'type'. By specifying 'type' I am telling the VisualCOBOL runtime to access a native .NET type (i.e. a class, interface or enum etc.), in this case the class "Environment" and execute a static method and the variable I want it to 'get' is contained within double quotes. Once you see the code and execute it, the process is really quite simple and straightforward. How about setting an environment variable though?

Setting Environment Variables

Before we can set an environment variable we have to ensure we're providing a valid name. A value of spaces is not acceptable so we want to ensure we don't provide spaces. We begin by first retrieving the value the user entered onto the screen into a working-storage variable defined in the program. The code to accomplish this is:



We then create an 'IF' statement to determine if the value is spaces or not. If it is not spaces we execute the method to set the environment variable the user defined.



This time we have to invoke a method to set the environment variable. We do this with the invoke statement and just as with setting an environment variable, we use the keyword 'type' to refer to a native .NET class directly, and thereby access a static method belonging to the class. In our case we're going to once again use the "Environment" class and this time we're going to execute the "SetEnvironmentVariable" method. This method takes two parameters, defined as strings. The first parameter is the name of the environment variable and the second is the value the parameter should contain. In our case we're going to read that value directly from the Text property of the textbox where the value was entered thus saving some time and resources in having to define a working-storage field.

Wrap-Up

The ZIP file has all the necessary source code for you to follow along and see how to use environment variables in VisualCOBOL. Being able to utilize an existing .NET assembly from within VisualCOBOL will greatly expand the interoperability and life of your existing COBOL applications. While the process may seem complicated at first, spend a few minutes and analyze what we've done in this article. The steps will be basically the same for you and will greatly extend the usefulness of your existing applications to the .NET Framework. And that's what it's all about.

Happy Coding!