We Keep Coding

Why should the Main() method be static?

I tried to create public void Main() in C#; it says no static void Main found.
What exactly does it mean for Main to be static? I know the code works fine for public static void Main().
But why does Main have to be static?

You need an entry point into your program. Static means that you can call the function without having to instantiate an object/instance of a class. It's a bit "chicken and egg"... you can't instantiate an object before you're inside the program.
A static method can be called without instantiating an object. Therefore main() needs to be static in order to allow it to be the entry to your program.
As David says, you can just add the keyword static to the function definition to change it. It's worth looking into static (class) methods vs instance methods, and knowing the difference can be useful at times.

Only the static main method can do the job because there is a convention that defines this behavior. There is not another reason.
Take a look at the C# language specification:
Application startup occurs when the execution environment calls a
designated method, which is referred to as the application's entry
point. This entry point method is always named Main, and shall have
one of the following signatures:
static void Main() {…}
static void Main(string[] args) {…}
static int Main() {…}
static int Main(string[] args) {…}
As shown, the entry point can optionally
return an int value. This return value is used in application
termination (§10.2).
Note: The above is quoted from the 4th edition, now labeled "historical". The current edition is worded differently.
In addition to that, the name Main can be changed to something else. In this case a compiler option must be added telling the C# compiler to mark a different method as the entry point of the program.

There are two types of method within a class:
Non-static method
Static method
// Example of static and non-static methods and how to call
namespace TestStaticVoidMain
{
class Program
{
Static Void Main(string[] args)
{
// Instantiate or create object of the non-static method:
Exam ob = new Exam();
// Call the instance:
ob.Test1();
// Directly the call the static method by its class:
Exam.Test2();
Console.ReadKey();
}
}
class Exam
{
public void Test1()
{
Console.WriteLine("This is a non-static method");
}
public static void Test2()
{
Console.WriteLine("This is a static method");
}
}
}
1. Static method:
To call a static method (function), we don't need to instantiate or create an object of that method. We can't use new keyword because, when the class is loaded and compiled, the static keyword by default instantiates or creates an object of that class method, so that is why we directly call a static method.
In reference to static void Main(string[] args), we already discussed static. The remainder is void Main(string[] args). void is a data type which returns nothing. Main() is the standard entry point to execution of a C# program. The optional argument string[] args receives the optional "command line" parameters that the program was run with.
2. Non-static sethod:
To call a non-static method, we have to instantiate or create an object of the class method to call the method (function) of the class using the keyword new.
If a class named Test has a non-static method named show(), then how it would call an instance:
// to call non-static method
Test ob=new Test();
ob.show();

Conceptually, it would be possible for a framework to specify that rather than using a particular static method to run a program, it will instead construct a default instance of some particular class and run some particular method thereon. If one had a framework which implemented static methods by having them be instance members of a compiler-initialized singleton instance, such an approach might be entirely reasonable, since the framework would have to generate a new object instance before calling the main function in any case.
If calling a static method is "easier" than constructing a new object instance and calling a method thereon, however, there isn't really much benefit to requiring that a framework use the more expensive course of action. Any code which wants to use the latter approach would be perfectly free to use:
public static void Main( [[params]] )
{
var mainObject = new MainObject();
mainObject.Main( [[params]] );
}
There could be some potential benefits to having the system include its own static method which looked something like:
public static void SysMain( [[params]] )
{
using (Application app = new UserApp( [[params]] )) // UserApp derives from Application
{
app.Start(); // Virtual method
app.AllowNext(); // Base method--see text
app.Run(); // Abstract method
}
}
where app.AllowNext() was a method to coordinate with other application instances launched at essentially the same time, to ensure that repeated attempts to launch an application in background would have their Start calls processed strictly sequentially. Absent such a coordination scheme, however, there's not really much benefit to requiring that the framework construct an application object before running it. The cost wouldn't be huge, but without any potential identifiable benefit there's not much point in accepting even a trivial cost.

During app startup, when no objects of the class have been created, the Main method must be called to begin program execution. Main is sometimes called the app’s entry point. Declaring Main as static allows the execution environment to invoke Main without creating an instance of the class. Method Main is typically declared with the header:
static void Main(){..}
but also can be declared with the header:
static void Main(string[] args){..}
You can declare Main with return type int (instead of void)—this can be useful if an app is executed by another app and needs to return an indication of success or failure to that other app.

The main should be static that it loads first and become your entry point to your program so it's crucial for the main to be static.

How does a static constructor work?

namespace MyNameSpace
{
static class MyClass
{
static MyClass()
{
//Authentication process.. User needs to enter password
}
public static void MyMethod()
{
//Depends on successful completion of constructor
}
}
class Program
{
static void Main(string[] args)
{
MyClass.MyMethod();
}
}
}
Here is the sequence which I assumed
Start of static constructor
End of static constructor
Start of main
Start of MyMethod
End of main
Now in any scenario if 4 will start before 2 I am screwed. Is it possible?

You only asked one question here but there are a dozen or so questions that you should have asked, so I'll answer them all.
Here is the sequence which I assumed
Start of class constructor (also known as cctor)
End of cctor
start of Main
start of MyMethod
Is this correct?
No. The correct sequence is:
Start of cctor for Program, if there is one. There is not.
End of cctor for Program, if there is one. There is not.
Start of Main
Start of cctor for MyClass
End of cctor for MyClass
Start of MyClass.MyMethod
What if there is a static field initializer?
The CLR is permitted to change the order in which static field initializers run in some cases. See Jon's page on the subject for details:
The differences between static constructors and type initializers
Is it ever possible for a static method like MyMethod to be called before the cctor of that class completes?
Yes. If the cctor itself calls MyMethod then obviously MyMethod will be called before the cctor completes.
The cctor does not call MyMethod. Is it ever possible for a static method like MyMethod to be called before the cctor of MyClass completes?
Yes. If the cctor uses another type whose cctor calls MyMethod then MyMethod will be called before the MyClass cctor completes.
No cctors call MyMethod, directly or indirectly! Now is it ever possible for a static method like MyMethod to be called before the cctor of MyClass completes?
No.
Is that still true even if there are multiple threads involved?
Yes. The cctor will finish on one thread before the static method can be called on any thread.
Can the cctor be called more than once? Suppose two threads both cause the cctor to be run.
The cctor is guaranteed to be called at most once, no matter how many threads are involved. If two threads call MyMethod "at the same time" then they race. One of them loses the race and blocks until the MyClass cctor completes on the winning thread.
The losing thread blocks until the cctor is done? Really?
Really.
So what if the cctor on the winning thread calls code that blocks on a lock previously taken by the losing thread?
Then you have a classic lock order inversion condition. Your program deadlocks. Forever.
That seems dangerous. How can I avoid the deadlock?
If it hurts when you do that then stop doing that. Never do something that can block in a cctor.
Is it a good idea to rely upon cctor initialization semantics to enforce complex security requirements? And is it a good idea to have a cctor that does user interactions?
Neither are good ideas. My advice is that you should find a different way to ensure that the security-impacting preconditions of your methods are met.

According to the MSDN, a static constructor:
A static constructor is called automatically to initialize the class
before the first instance is created or any static members are
referenced.
So the static constructor will be called before the static method MyClass.MyMethod() is invoked (assuming not also invoked during static construction or static field initialization of course).
Now, if you are doing anything asynchronous in that static constructor, then it's your job to synchronize that.

The #3 is actually #1: static initialization does not start until the first use of the class to which it belongs.
It is possible if MyMethod is called from the static constructor or a static initialization block. If you do not invoke MyMethod directly or indirectly from your static constructor, you should be fine.

From the documentation (emphasis mine):
A static constructor is called automatically to initialize the class
before the first instance is created or any static members are
referenced.

You can guarantee 4 will always come after 2 (if you don't create a instance of your class from your static method), however the same is not true for 1 and 3.

The static constructor will be called before mymethod is executed. However if you are screwed if 4 is called before 2 then I suggest you re-think your design. Should not be doing complicated stuff in a static constructor anyway.

The CLR guarantees that the static constructor runs before any static members are accessed. However, your design is a bit smelly. It would be more straightforward to do something like this:
static void Main(string[] args)
{
bool userIsAuthenticated = MyClass.AuthenticateUser();
if (userIsAuthenticated)
MyClass.MyMethod();
}
With your design, if authentication fails, the only way to prevent MyMethod from running is by throwing an exception.

It's ensured that a static class's constructor has been called before any of its methods get executed. Example:
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Press enter");
Console.ReadLine();
Boop.SayHi();
Boop.SayHi();
Console.ReadLine();
}
}
static class Boop
{
static Boop()
{
Console.WriteLine("Hi incoming ...");
}
public static void SayHi()
{
Console.WriteLine("Hi there!");
}
}
Output:
Press enter
// after pressing enter
Hi incoming ...
Hi there!
Hi there!

Here's the actual order in which things go down:
Start of Main
Start of the static MyClass constructor
End of the static MyClass constructor
Start of MyMethod
End of Main

Or you could step through in the debugger.

C# entry point function

Is it necessary to use static void main() as the entry point function in C#, or can we use some other function?
Why is main() static?

Before C# 9, the entry point had to be declared explicitly. C# 9 introduces top level statements which allow the entry point to be generated implicitly. (Only a single source file in a project can include top-level statements, however.)
When the entry point is declared explicitly, it has to be Main. It's static because otherwise the CLR would need to worry about creating an instance of the type - which means you'd presumably have to have a parameterless constructor, even if you didn't want an instance of the type, etc. Why would you want to force it to be an instance method?
Even with top-level statements, your actual program still has an entry point called Main - it just doesn't appear in your source code.

Yes, for a C# application, Main() must be the entry point.
The reason is because that's what the designers of the language decided to be what to look for as an entry point for your program. They could just as well have used a totally different approach to find the entry point, e.g. using meta data, or instantiating an object for you (which would require a parameterless constructor). Another reason for naming it void main() is that it's intuitive for users coming from other languages.

static void Main() is the necessary entry point for any "Executable" (.EXE) to be created in C#. A library (or .DLL) can have other entry points.
The method is static because that is required in order to access the method without having an instance of the object to address. In order to invoke the method (starting point) from outside the application, a static method is required.

Since C# 9 you can now remove the boilerplate through Top-level statements.
Before:
using System;
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
Newly possible:
using System;
Console.WriteLine("Hello World!");
Source: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9#top-level-statements
If you insist on using the Main function as the entry point, more information can be found here

The required entry point is actually:
static void Main(string[] args); // note capitalization and arguments
The reason that Main must be static is that non-static objects must be constructed before you call any methods on them. Since Main is the entrance point of the program, who's going to call its constructor?
(Yes, you could have the CLR require that the class with Main contain a default parameterless constructor, and make the CLR call that constructor during global startup. But that's extra work, and in practice it's easier to just require that Main be static.)

The Main method might be what you consider as the entry point of an application but in c# as far as i know methods can't be defined directly in namespaces which means it has to be within a class. The real first executed thing then is the static constructor of the class containing the Main method
using System;
namespace test
{
class Program
{
static Program()
{
Console.WriteLine("static constructor");
}
public static void Main(string[] args)
{
Console.WriteLine("Main method");
}
}
}
Outputs static constructor first and then Main method

static int Main(string[] args) is static because it reduces the number of potential steps the runtime needs to go through before it can start executing the entry point of your program (run class's static constructor, run class's static Main... versus run class's static constructor, instantiate the class into some location that's undefined, run instance's constructor, then run instance's Main method). You'd have to write boilerplate code to store this into an instance variable you could use (and likely to keep it from going out of referential scope which would enable it to be garbage-collected) which would also tend to increase the reference count and require a little more memory and pricessing for not much gain.
It's named Main because C# is strongly reminiscent of Java in its design, and Java uses the name Main, which itself derives from a slight differentiation (case is a thing!) from C and C++.

C# static garbage collector?

I have a simple class which has a static constructor and a instance constructor. Now when i initialized the class , both static and instance constructor are called. Only static is referred once in a application domain . Can i again call the same class initialization and static constructor initialize again? I have tried but it didn't happen? Is there any way we can call static constructor again in main() method after using garbage collection on the class.
Here is the code:
public class Employee
{
public Employee()
{
Console.WriteLine("Instance constructor called");
}
static Employee()
{
Console.WriteLine("Static constructor called");
}
~Employee()
{
//Dispose();
}
}
Now in main method call:
static void Main(string[] args)
{
Employee emp = new Employee();
Employee emp = new Employee();
}
Output:
Static constructor called
Instance constructor called
Instance constructor called
Now the static didn't called again. Because it is called once in application domain. But is their any way we could call it again without unloading application domain. Can we use GC class over here?
Thanks.
Pal

Unless you prod it with reflection, the static constructor (or more generally, the type initializer) is only executed once per concrete class, per AppDomain.
Note that for generics, using different type arguments you'll get different concrete classes:
public class Foo<T>
{
Foo()
{
Console.WriteLine("T={0}", typeof(T));
}
public static void DummyMethod() {}
}
...
Foo<int>.DummyMethod(); // Executes static constructor first
Foo<string>.DummyMethod(); // Executes static constructor first
Foo<string>.DummyMethod(); // Type is already initialized; no more output

Not possible. The CLR keeps an internal status bit that tracks whether the type initializer was started. It cannot run again. That status bit is indeed stored in the loader heap as part of the AppDomain state. The workaround is simple, just add a static method to the class.

The point of a constructor is to put things into a desired initial valid state.
An instance constructor puts an instance into an initial valid state.
An instance constructor that takes arguments puts an instance into a initial valid state that reflects its arguments.
A static constructor puts the type into an initial valid state. E.g. initialising static members used by the class' static methods or shared by all instances.
Ideally all methods will leave the object and the type in a valid state, but constructors differ in being responsible for getting it into one in the first place.
Any attempt to call a constructor twice is therefore a mistake, since "put it into an initial valid state again" isn't something you can logically do twice ("initial" and "again" don't work well in the same clause). We are helped by the compiler (in it refusing to compile) and the language (in there being no way to express this) from doing such a thing.
And, being a logical impossibility it isn't something you can actually want to do (well, I can want to draw a triangle with more than 3 sides, but only to say that I did). This suggests that you are using your constructor to do something other than setting up an initial valid state.
Doing anything other than establishing such a valid state in a constructor is (as is failing to do so) at best an optimisation, quite often a serious design flaw and quite possibly (worse of all because it goes unfixed longer) an attempted optimisation that is really a serious design flaw.
One sign that your attempt at an optimisation is really a design flaw is a desire to call a static constructor more than once, or to call an instance constructor more than once on the same object.
Identify the desired repeatable behaviour, move it into a separate method, and have it called as needed from both the constructor and elsewhere. Then double check your design's logic, as this is quite a serious mistake to find in a class design and suggests you've got deeper problems.

Static method and threads

I have put one question on MSDN forum but got two opposite answers. In general I am intersted how threading works with static classes. If my code calls this(below) static method from 10 threads at the same time, is it thread safe? I mean, how the code flows behind the scenes? Does every thread executes the code within itself (like I think it does with non-static classes) or it is different with static method and, because its static, all threads try to reach the code and collide? Thanks!
public static class A
{
static void Method(object parameter)
{
SqlCeConnection = .....
}
}
Link to MSDN question: Here
PS: I am sorry due to IE page errors I cannot click on "Add comment" or "Answer", Jon Skeet answer is good (as usually :)

It's exactly the same as with non-static classes. Being static doesn't affect anything really - except that static methods are generally expected to be thread-safe. They're not automatically thread-safe, but you should make sure that you implement them in a thread-safe manner.
If the code doesn't use any shared state, it should be fine. And yes, without any locking, all the threads can be executing the same method concurrently.

A nice example can be singleton pattern.In this all you need is a single instance for a given class and that can be made sure by making the constructor private and giving a static method or property to access the instance.Following code snippets highlight the same :-
class MyClass
{
private MyClass()
{
}
public static MyClass Instance
{
get
{
lock(typeof(MyClass))
{
if(__instance == null)
__instance = new MyClass();
}
return __instance;
}
}
}
Since the "Instance" method is marked static(thread consistent access) , but in multi threaded envoirnment you need to manully take care of it(using lock).