• datové typy a velikosti
• uložení záporných čísel (přímý, doplňkový kód)
• desetinná čísla
• hodnotové a referenční typy
• platnost proměnných
• Operátory
• Enumy
• Přetížení operátorů

Proměnné v programování jsou pojmenovaná úložiště dat, která umožňují programům uchovávat a manipulovat s hodnotami během svého běhu. Každá proměnná má jméno a může obsahovat různé typy dat, jako jsou čísla, text nebo logické hodnoty.

Celočíselné hodnoty
Název	Rozsah	Velikost	.NET
sbyte	-128 až 127	8 bitů	System.SByte
byte	0 až 255	8 bitů	System.Byte
short	-32 768 až 32 767	16 bitů	System.Int16
ushort	0 až 65 535	16 bitů	System.UInt16
int	-2 147 483 648 až 2 147 483 647	32 bitů	System.Int32
uint	0 až 4 294 967 295	32 bitů	System.UInt32
long	-9 223 372 036 854 775 808 až 9 223 372 036 854 775 807	64 bitů	System.Int64
ulong	0 až 18 446 744 073 709 551 615	64 bitů	System.UInt64

Číselné typy s plovoucí desetinnou čárkou
Název	Rozsah ±	Přesnost	Velikost	.NET
float	1,5 × 10^-45 až 3,4 × 10^38	7 číslic	32 bitů	System.Single
double	5,0 × 10^-324 až 1,7 × 10^308	15 číslic	64 bitů	System.Double
decimal	1,0 × 10^-28 až 7,9 × 10^28	28 číslic	128 bitů	System.Decimal

Velikosti číselných proměných jde zjistit pomocí kódu v c# například takto:

        
  byte.MaxValue;
  byte.MinValue;
  
  short.MaxValue;
  short.MinValue;
  
  int.MaxValue;
  int.MinValue;
  
  long.MinValue;
  long.MaxValue;
  
  float.MaxValue;
  float.MinValue;
  
  double.MaxValue; 
  double.MinValue;
  
  decimal.MaxValue; 
  decimal.MinValue;
        
    

Ostatní důležité typy
Název	Rozsah	Velikost	.NET
boolean	true nebo false	1 bajt	System.Boolean
char	0 až 65 535	16 bitů	System.Char

Existuji více možností, jak uložit záporné čísla. Nejčastěji se používá přímý kód (sign-magnitude) nebo doplňkový kód (two's complement).

Desetinná čísla se ukládají pomocí IEEE 754. Tento způsob ukládání je velmi přesný a umožňuje ukládat i velmi malé čísla.
Při ukládání desetinných čísel je důležité si uvědomit, že počítače nemohou ukládat desetinná čísla přesně.
Desetinná se skládají z

S	znaménko	1 bit
E	Exponent	8 bit
M	mantisa	23 bit

0 pro kladné číslo
1 pro záporné číslo

(-1) na s

(-1) na 0 = 1
(-1) na 1 = -1 Exponent je uložen záporně, což znamená, že na to abychom dostali hodnotu exponentu, musíme odečíst 127. Je to podobné jako u doplňkového kódu.

2 na E - 127
Mantisa je vlastně to uložené číslo ke které se přičte 1. Ale narozdíl od normálního násobení s 2 na x budeme násobit 2 na -x, tudiž nám vznikne zlomek

2⁻¹ = ½
2⁻² = ¼
2⁻³ = ⅛
2⁻⁴ = 1/16....



je duležité si uvědomit, že tím jak se ukládá jako násobení není možné ukládat všechna čísla přesně.
Obvyklý problem nastava třeba při uložení 0.1, protože 0.1 je 1/10 a 1/10 je 0.000

Proměnné jsou dva základní druhy proměnných v programování, které ovlivňují to, jak jsou data v paměti uložena a jak se s nimi pracováno.

základní vliv na platnost proměnné má její umístění v programu. Přesně řečeno její umístění vzhledem k begin a end ({ a }).
Tyto složené závorky neboli begin a end mají prostý význam. Označují vždy nějaký blok kódu a obecně platí, že deklarované proměnné platí pouze uvnitř tohoto a podřízených blocích tj. dalších blocích begin a end v něm vložených.

V jazyce C# existují čtyři přístupové operátory, které určují, jakým způsobem mohou být členy třídy přístupné z jiných částí programu

1. public - Členy třídy s tímto modifikátorem jsou přístupné z jakéhokoli místa v programu.
2. private - Členy třídy s tímto modifikátorem jsou přístupné pouze z této třídy.
3. protected - Členy třídy s tímto modifikátorem jsou přístupné z této třídy a z odvozených tříd.
4. internal - Členy třídy s tímto modifikátorem jsou přístupné pouze z těch částí programu, které jsou v rámci stejného sestavení

Přístupové operátory se používají k řízení přístupu k členům třídy, jako jsou proměnné, metody a vlastnosti. Přístupové operátory jsou důležité pro zachování bezpečnosti a správného fungování programu
Například:

    
        // public class:
        public class Tricycle
        {
            // protected method:
            protected void Pedal() { }

            // private field:
            private int _wheels = 3;

            // protected internal property:
            protected internal int Wheels
            {
                get { return _wheels; }
            }
        }
        
    

symbol používaný ve výrazech, který předepisuje provedení nějaké (nejčastěji matematické nebo logické) operace s hodnotami (operandy) zapsanými ve svém okolí.

Enum je speciální "třída", která reprezentuje skupinu konstant.
Enumy jsou užitečné, když potřebujeme definovat soubor konstant, které jsou přiřazeny číselným hodnotám.
Například:

Ano	0
Ne	1
Možná	50
nevim	51

    
        enum Odpovedi
        {
            Ano,         // 0
            Ne,          // 1
            Možná = 50,  // 50 Počítá dál..
            nevim        // 51
        }
        
    

Chtěli jste někdy sčítat dvě instance vaší třídy?
Přetížení operátorů vám to umožní.
Musí být public a static.

    
    public class Cube
    {
        public int Length { get; set; }
        
        public Cube(int length)
        {
            Length = length;
        }

        public static Cube operator -(Cube left, Cube right)
        {
            return new Cube() { Length = left.Length - right.Length };
        }

        public static int operator +(Cube left, Cube right)
        {
            return left.Length + right.Length;
        }
    }
    public static void Main()
    {
        var a = new Cube(5);
        var b = new Cube(1);
        Console.WriteLine(a + b);  // vysledek: 5 + 1 = 6
        Console.WriteLine(a - b);  // vysledek: new Cube(4)
    }