If you’re asking what the idea of “type-safe” in general means, it’s the characteristic of code that allows the developer to be certain that a value or object will exhibit certain properties (i.e., be of a certain type) so that he/she can use it in a specific way without fear of unexpected or undefined behavior.
For instance, in C#, you could say the ArrayList class is not type-safe because it can store any object, which means you can do something like the following:
var integers = new ArrayList();
integers.Add(1);
integers.Add(2);
integers.Add("3");
for (int i = 0; i < integers.Count; ++i) {
int integer = (int)integers[i];
// do something
}
The above will compile because the value “3”, even though it’s a string and not an integer, can legally be added to an ArrayList since String derives (like Int32) from Object. However, it will throw an InvalidCastException when you try to set integer to (int)integers[2] because a String cannot be cast to an Int32.
On the other hand, the List<T> class is type-safe for exactly the opposite reason–i.e., the above code would not compile if integers were a List<int>. Any value that you the developer access from within a type-safe List<int> you can be certain is an int (or whatever the corresponding T is for any generic List<T>); and you can therefore be sure that you’ll be able to perform operations such as casting to int (obviously) or, say, long.