What is Type safe in C#?

Type safety in C# is a fundamental feature that prevents objects from accessing memory locations that don't belong to them. This means you cannot accidentally treat one object type as another incompatible type, which helps prevent runtime errors and memory corruption.

The C# compiler enforces type safety at compile time, ensuring that operations are performed only on compatible types. This prevents common programming errors like accessing invalid memory locations or calling methods that don't exist on an object.

How Type Safety Works

C# prevents unsafe type conversions through compile-time checking. When you attempt to cast an object to an incompatible type, the compiler generates an error before the code can run −

using System;

public class One {
    public int Prop { get; set; }
}

public class Two {
    public int Prop { get; set; }
    public int Prop1 { get; set; }
}

public class Program {
    public static void Main() {
        One ob = new One();
        ob.Prop = 10;
        
        // This would cause a compile-time error:
        // Two ob2 = (Two)ob;  // Cannot convert type 'One' to 'Two'
        
        Console.WriteLine("Object created successfully: " + ob.Prop);
    }
}

The output of the above code is −

Object created successfully: 10

Safe Type Conversions

C# provides safe ways to check and convert types using the is and as operators −

using System;

public class Animal {
    public virtual void Sound() {
        Console.WriteLine("Animal makes a sound");
    }
}

public class Dog : Animal {
    public override void Sound() {
        Console.WriteLine("Dog barks");
    }
    
    public void Fetch() {
        Console.WriteLine("Dog fetches the ball");
    }
}

public class Program {
    public static void Main() {
        Animal animal = new Dog();
        
        // Safe type checking with 'is'
        if (animal is Dog) {
            Console.WriteLine("animal is a Dog");
        }
        
        // Safe type conversion with 'as'
        Dog dog = animal as Dog;
        if (dog != null) {
            dog.Sound();
            dog.Fetch();
        }
    }
}

The output of the above code is −

animal is a Dog
Dog barks
Dog fetches the ball

Benefits of Type Safety

• Memory Protection: Prevents objects from accessing memory that doesn't belong to them.

• Compile-time Error Detection: Catches type-related errors before the program runs.

• Runtime Stability: Reduces crashes and unpredictable behavior in applications.

• IntelliSense Support: IDEs can provide accurate code completion and error highlighting.

Type Safety vs Unsafe Code

While C# is type-safe by default, it also allows unsafe code blocks for performance-critical scenarios −

using System;

public class Program {
    public static void Main() {
        // Type-safe approach
        int[] numbers = {1, 2, 3, 4, 5};
        Console.WriteLine("Type-safe access: " + numbers[2]);
        
        // Attempting invalid access would throw IndexOutOfRangeException
        // Console.WriteLine(numbers[10]); // Runtime exception
        
        Console.WriteLine("Type safety prevents memory corruption");
    }
}

The output of the above code is −

Type-safe access: 3
Type safety prevents memory corruption

Conclusion

Type safety in C# is a crucial feature that prevents objects from accessing memory locations belonging to other objects. The compiler enforces type compatibility at compile time, catching potential errors before they can cause runtime issues or memory corruption.