Statický jsou vždy přístupny i když instance není nijak declarovaná.
Jedná se všudepřístupné hodnoty , avšak s timto musíme velmi opratrně pracovat.

    

// Dá se zavolat 

Foo.Xxx();
Foo.Value = 5;

public class Foo
{
    public static int Value;

    public static void Xxx()
    {

    }

    public void Test
    {

    }


}
    

Statický konstruktor se spouští v momentě, když vyvoláme jakoukoliv statickou

• Metodu
• Parametr
• novou instanci (new neco())

zavolá se jen jednou a nesmí mít žádné parametry

    

// Dá se zavolat 
// všechno zavolá statický konstrukor, ale pouze jednou.

Foo.Xxx(); // zde se zavolá konstruktor
Foo.Value = 5;

public class Foo
{
    public static int Value;

    static Foo()
    {

    }

    public static void Xxx()
    {

    }
}
    

Lze definovat třídu ve třídě, avšak lze použít vně třídy a mimo třídy , za předpokladu, že je vnitřní třída public.
Umožnuje použití struktury, kterou nechceme ventilovat ven.

    

LinkedList list = new LinkedList();
LinkedList.Item item = new LinkedList.Item();

public class LinkedList
{
    private Item first;

    // Lze vidět
    public class Item
    {

    }

    // Neni vidět
    private class SecureItem
    {

    }
}
    

Pokud vytváříme například list, tak jsme momentalní chvíly limitovaný pouze na to co zadáme jako typ, momentální chvíly int.
Kdybychom chtěli string, tak musime opět vytvořit to stejný, ale s jiným

    
public class MyListInt
{
    private int[] data;

    private int count;

    public void Add(int value)
    {
        this.data[this.count++] = value;
    }
}

public class MyListString
{
    private string[] data;

    private int count;

    public void Add(string value)
    {
        this.data[this.count++] = value;
    }
}
    

Mužeme použit něco co se jmenuje generický a umožnuje nám určit o jaký typ se bude jednat

    
public class MyListInt<T>
{
    private T[] data;

    private int count;

    public void Add(T value)
    {
        this.data[this.count++] = value;
    }
}
    // mužeme mít i více 
public class MyList<TKey, TValue> 

    // I na více mužeme definovat jejich typy
public class MyList<TKey, TValue> where TKey : class, IDisposable
                                       where TValue : new()

    // hodnotovy typ
public class MyList<T> where T : struct 

    // bez parametrický konstrukor
public class MyList<T> where T : new 

    // referenční typ
public class MyList<T> where T : class 
{
    private T[] data;

    private int count;

    public void Add(T value)
    {
        this.data[this.count++] = value;
    }
}

// mužeme dělat i metodu, nemusíme se omezovat na classy
public static void GetNazevAnicka<T> (List<T> Value1, T Value2) 
{

}