Proper way of using C# global variables in ASP.NET?

Question

I am using ASP.NET Web Forms and C# in my application. I have a class file named Global.cs, in which I define variables using set and get properties. I use those variables anywhere on any pages by instantiating that class object.

Here is my Global.cs file:

using System;
using System.Data;
using System.Linq;
using System.Web;

/// <summary>
/// Contains my site's global variables.
/// </summary>
public static class Global
{
    /// <summary>
    /// Global variable storing important stuff.
    /// </summary>
    public static string gDate;
    public static string gMobLength;
    public static string gDateFormat;
    public static string gApplicationNo;
    public static string gBranchNo;
    public static string gMemId;
    public static string gIsEditable="false";
    public static string gLoggedInUserName;


    public static string ImportantData
    {
        get
        {
            return gDate;

        }
        set
        {
            gDate = value;

        }

    }
    public static string MobileLength
    {
        get
        {
            return gMobLength;
        }
        set
        {
            gMobLength = value;
        }
    }

    public static string DateFormat
    {
        get
        {
            return gDateFormat; 
        }
        set
        {
            gDateFormat = value; 
        }
    }
    public static string ApplicationNo
    {
        get
        {
            return gApplicationNo;
        }
        set
        {
            gApplicationNo = value; 
        }
    }
    public static string BranchNo
    {
        get
        {
            return gBranchNo; 
        }
        set
        {
            gBranchNo = value;
        }
    }

}

Is this a proper way of using variables throughout the project? What are the possible pros and cons with this approach and what approach would you guys take for using global variables?

tofutim · Accepted Answer · 2015-09-21 18:08:45Z

4

First, I'd recommend using autoimplemented properties.

public static string BranchNo { get; set; }

Simplifies your code a bit. As to whether or not this is a good approach, it depends. Sometimes simple and straight-forward is better, and this falls into that category. If the values should not change once initialized, you may want to use a proper singleton with initialization:

public class Settings
{
   private static Settings _current;
   private static readonly object _lock = new object();

   public static Settings Current
   {
      get
      {
         lock(_lock)
         {
            if (_current == null) throw new InvalidOperationException("Settings uninitialized");
            return _current;
         }
      }
      set
      {
          if (value == null) throw new ArgumentNullException();
          if (_current != null) throw new InvalidOperationException("Current settings can only be set once.");

          if (_current == null)
          {
              lock(_lock)
              {
                 if (_current == null) _current = value;
              }
          }
      }
   }


   public string ImportantData { get; private set; }

   // etc. 
}

Initializing settings:

Settings.Current = new Settings{ ImportantData = "blah blah blah"};

Accessing:

var data = Settings.Current.ImportantData;

edited Sep 21, 2015 at 18:08

tofutim

23.6k20 gold badges91 silver badges160 bronze badges

answered Jun 9, 2012 at 6:04

moribvndvs

42.5k12 gold badges138 silver badges152 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

Priyank Patel Over a year ago

@HackedByChinese Thanks for the suggestion , What is the difference between my approach and the approach you suggested to simplify my code.Thanks.

moribvndvs Over a year ago

Autoimplemented properties automatically generate the backing field, so you don't have to include them in your source.

L.B Over a year ago

Wouldn`t a simple Lazy be enough?

Daniel Marín Over a year ago

Settings.Current = new Settings{ ImportantData = "blah blah blah"}; will cause a compilation error because the "set" is unnaccesible.

Daniel Marín Over a year ago

Here is the fiddle which demonstrates my previous comment.

paulsm4 · Accepted Answer · 2012-06-09 06:03:05Z

2

Outside of the two bromides "globals are bad" and "properties are good" ... there's nothing intrinsically wrong with your approach. Go for it!

IMHO .. PSM

answered Jun 9, 2012 at 6:03

paulsm4

123k23 gold badges175 silver badges245 bronze badges

2 Comments

Priyank Patel Over a year ago

Ok thanks for the advice , can I ask what is IMHO PSM , might be sounding silly.Thanks.

paulsm4 Over a year ago

"PSM" is my name :). "IMHO" means "In My Humble Opinion". And I honestly didn't notice that you were already using properties: I thought you just had a bunch of public static variables. Which, IMHO, can be perfectly OK.

Nas · Accepted Answer · 2012-06-09 09:08:37Z

1

The reason why you do not see the variable after you instantiate that class object is because the variables are declared as static. Static variables are meant to be used by that manor ClassName.variableName or ClassName.PropertyName

answered Jun 9, 2012 at 9:08

Nas

1,1433 gold badges11 silver badges23 bronze badges

Collectives™ on Stack Overflow

Proper way of using C# global variables in ASP.NET?

3 Answers 3

5 Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

5 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related