CODEWITHSUNDEEP
c#classstaticstatic-classesstatic-constructor
MrProgram
MrProgram

Reputation: 5242

How to pass parameter to static class constructor?

I have a static class with a static constructor. I need to pass a parameter somehow to this static class but I'm not sure how the best way is. What would you recommend?

public static class MyClass {

    static MyClass() {
        DoStuff("HardCodedParameter")
    }
}

Upvotes: 47

Views: 69816

Answers (4)

GDavoli
GDavoli

Reputation: 606

Constructors on non-static class have have the benefit to ensure they're properly initialized before they're actually being used.

Since static classes don't have this benefit, you have to make ensure that yourself.

Use a static constructor with an obvious name, then in the relevant portion of your static procedures check to make sure the initialization has been performed. The example below assumes your want to "initialize" your static class with a Form object.

    public static class MyClass
    {
        private static Form FormMain { get; set; }

        public static void Init(Form initForm)
        {
            FormMain = initForm;
        }

        private static bool InitCheck()
        {
            return FormMain != null ? true: false;
        }

        public static void DoStuff()
        {
            if (InitCheck())
            {
                // Do your things
            }
            else
            {
                throw new Exception("Object reference not set to an instance of an object");
            }
        }
    }

Upvotes: 0

Rahul Nikate
Rahul Nikate

Reputation: 6337

As per MSDN, A static constructor is called automatically to initialize the class before the first instance is created. Therefore you can't send any parameters.

CLR must call a static constructor, how will it know which parameters to pass it?

So don't use a static constructor.

Here's the work around for your requirement.

public class StaticClass 
{ 
  private int bar; 
  private static StaticClass _foo;

  private StaticClass() {}

  static StaticClass Create(int initialBar) 
  { 
    _foo = new StaticClass();
    _foo.bar = initialBar; 
    return _foo;
  } 
}

Static constructors have the following properties:

  • A static constructor does not take access modifiers or have parameters. A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
  • A static constructor cannot be called directly.
  • The user has no control on when the static constructor is executed in the program.
  • A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.
  • Static constructors are also useful when creating wrapper classes for unmanaged code, when the constructor can call the LoadLibrary method.
  • If a static constructor throws an exception, the runtime will not invoke it a second time, and the type will remain uninitialized for the lifetime of the application domain in which your program is running.

Upvotes: 10

Mateusz Myślak
Mateusz Myślak

Reputation: 845

If by "HardCodedParameter" you really mean hard coded, you can use constants.

public static class YoursClass
{ 
    public const string AnotherHardCodedParam = "Foo";
}

public static class MyClass
{
    private const string HardCodedParam = "FooBar";

    static MyClass()
    {
        DoStuff(MyClass.HardCodedParam);
        DoStuff(YoursClass.AnotherHardCodedParam);
    }
}

Also, you can use static readonly properties.

Upvotes: 0

Matías Fidemraizer
Matías Fidemraizer

Reputation: 64923

Don't use a static constructor, but a static initialization method:

public class A
{
    private static string ParamA { get; set; }

    public static void Init(string paramA)
    {
        ParamA = paramA;
    }
}

In C#, static constructors are parameterless, and there're few approaches to overcome this limitation. One is what I've suggested you above.

Upvotes: 69

Related Questions