Jaké jsou typy převodů v C#?

V jazyce C# existují dva hlavní typy konverze:

Explicitní konverze (Explicit conversion): Vyžaduje použití operátoru (typ). Používá se, když kompilátor nemůže bezpečně provést konverzi automaticky, například při převodu z základní třídy na odvozenou nebo z typu s vyšší přesností na typ s nižší přesností (například double na int). To může vést ke ztrátě dat nebo chybám za běhu (InvalidCastException).
```
// Explicitní konverze z double na int
double d = 123.45;
int i = (int)d; // i bude 123

// Převod objektu na konkrétní typ
object obj = "Hello";
string s = (string)obj; // s bude "Hello"
```

Implicitní konverze (Implicit conversion): Probíhá automaticky kompilátorem, když je konverze známá a bezpečná, tj. bez ztráty dat. Například převod z int na double.

// Implicitní konverze z int na double
int x = 10;
double y = x; // y bude 10.0

// Implicitní konverze od odvozené třídy na základní
class Base {}
class Derived : Base {}

Derived derivedObj = new Derived();
Base baseObj = derivedObj; // Implicitní konverze

Navíc existují operátory as a is, které se také týkají konverze typů, ale s určitými vlastnostmi:

Operátor as: Provádí konverzi typu, pokud je možná, a vrací null, pokud se nepodaří. Nevyvolává výjimku InvalidCastException. Používá se pouze s referenčními typy a Nullable typy.
```
// Použití operátoru `as`
object obj2 = "World";
string s2 = obj2 as string; // s2 bude "World"

object obj3 = 123;
string s3 = obj3 as string; // s3 bude null
```

Operátor is: Kontroluje, zda je objekt instancí určitého typu nebo typu od něj odvozeného. Vrací true nebo false. V nejnovějších verzích C# může být použit s pattern matching, což umožňuje současně kontrolu a konverzi.

// Použití operátoru `is` pro kontrolu typu
object obj4 = "Example";
if (obj4 is string)
{
    // Akce, pokud je objekt řetězec
}

// Použití `is` s pattern matching
if (obj4 is string str)
{
    // str je dostupný zde jako řetězec
}