C# in Depth

42 CHAPTER 2 Core foundations: building on C# 1Delegates are one very specific feature of C# and .NET—a detail, in the grand schemeof things. Both of the other “reminder” sections in this chapter deal with muchbroader topics. First, we will consider what it means to talk about C# being a staticallytyped language and the implications that has.2.2 Type system characteristicsAlmost every programming language has a type system of some kind. Over time, thesehave been classified as strong/weak, safe/unsafe, static/dynamic, and no doubt somemore esoteric variations. It’s obviously important to understand the type system withwhich one is working, and it’s reasonable to expect that knowing the categories intowhich a language falls would give a lot of information to help on that front. However,because the terms are used to mean somewhat different things by different people,miscommunication is almost inevitable. I’ll try to say exactly what I mean by each termto avoid confusion as much as possible.One important thing to note is that this section is only applicable to “safe” code—which means all C# code that isn’t explicitly within an unsafe context. As you mightjudge from the name, code within an unsafe context can do various things that safecode can’t, and that may violate some aspects of normal type safety. Most developersare unlikely ever to need to write unsafe code, and the characteristics of the type systemare far simpler to describe and understand when only safe code is considered.This section shows what restrictions are and aren’t enforced in C# 1 while definingsome terms to describe that behavior. We’ll then see a few things we can’t dowith C# 1—first from the point of view of what we can’t tell the compiler, and thenfrom the point of view of what we wish we didn’t have to tell the compiler.Let’s start off with what C# 1 does, and what terminology is usually used to describethat kind of behavior.2.2.1 C#’s place in the world of type systemsIt’s easiest to begin by making a statement, and then clarify what it actually means andwhat the alternatives might be:C# 1’s type system is static, explicit, and safe.You might well have expected the word strong to appear in the list, and I had half amind to include it. However, while most people can reasonably agree on whether alanguage has the listed characteristics, deciding whether or not a language is stronglytyped can cause heated debate because the definitions vary so wildly. Some meanings(those preventing any conversions, explicit or implicit) would clearly rule C# out—whereas others are quite close to (or even the same as) statically typed, which wouldinclude C#. Most of the articles and books I’ve read that describe C# as a stronglytyped language are effectively using it to mean statically typed. I’ve used the word statichere to try to minimize the potential for confusion—although it should be noted thatit has little in common with the common understanding of the keyword static usedwithin code itself as related to the type rather than a particular instance.Let’s take the terms in the definition one at a time and shed some light on them.Licensed to Rhona Hadida