The static keyword in C# is refering to something in the class, or the class itself, that is shared amongst all instances of the class.  For example, a field that is marked as static can be accessed from all instances of that class through the class name.

public class SomeObject
{
    //Static Field
    static int Foo = 3;

    //instance field
    private int _Foo2 = 4;

    //instance property
    public int Foo2{get{return _Foo2;}set{_Foo2 = value;}}


    //static constructor
    public static SomeObject CreateSomeObject(int fooValue)
    {
        SomeObject retVal = new SomeObject();
        retVal.Foo2 = fooValue;
        return retVal;
    }

    //Parameterless instance constructor
    public SomeObject()
    {
    }

    public static int Add(int x)
    {
        //Static methods can only deal with local variables, or fields that
        //  are also static in the class.  This one adds x to the static member foo
        return x + Foo;

        //Foo2 is not accessable here!
    }

      //Instance method
    public void AddSomething(int x)
    {
        //Add x to the property value of Foo2
        return x + this.Foo2;

        //Note that Foo *is* accessable here as 'SomeObject.Foo'
    }

}


I can honestly say that I have never used a class marked as static with the exception of creating extention methods (Quick tutorial on extension methods).

Anyways, there are specific design patterns for utilizing static methods, such as factory pattern and singleton pattern, but the important thing to remember is that static methods and constructors do not deal with any specific instance of a class (unless you pass one in).  So utilizing static methods is more of a stateless implementation of a methods, e.g. to do calculations or to do a comparison between objects. The "Main" method you are refering to is always static, but to see it from a different point of view, see this article.

To follow up with this, here is how the difference between static and instantiated methods, fields and properties are called.

public static void Main(string[] args)
{
    //This is a static method that starts a thread in an application
    // space.  At this point not everything actually has to be static...

    //Here is an instantiation with a parameterless contruction
    SomeObject obj = new SomeObject();

    //Here is an instantiation using a static contructor (factory)
    SomeObject obj2 = SomeObject.CreateSomeObject(3);

    //Getting field value from static field
    // Notice that this references the class name, not an instance
    int fooValue1 = SomeObject.Foo;

    //Getting property value from instance
    //  Note that this references an object instance
    int fooValue2 = obj2.Foo2;

    //Instance method must be called through an object
    obj2.AddSomething(4);  //if default constructor, would return 8

    //Static methods must be called through class name
    SomeObject.Add(4); //Returns 7
}


Also, check this post out for a deeper look into static classes.

Understanding the static keyword
I'm looking into a Caucasus trip visiting Turkey, Georgia and Armenia. A return flight from IST is far cheaper than a multi-city flight, so I'd like to get back to Istanbul without going over the same route I came in (through Georgia, which as I understand seems to be the only way to get to Armenia from Turkey)

Given local neighbour relations, what path can I take that includes all three but doesn't repeat any part of the journey ?

To return from Armenia, I see two equally unreliable options: 


Getting an Azerbaijan transit visa and crossing Naxchivan, but the Armenia-Azerbaijan border is apparently closed, and I'm afraid an Armenian stamp in my passport could complicate this passage. The Armenia-Azerbaijan border is closed, so that settles this issue.
Getting an Iranian visa in Georgia then boarding the Tehran-Istanbul train. This is risky as Canadian-Iranian relations aren't super right now, I've heard of people being denied visas.

