Bummer! This is just a preview. You need to be signed in with a Basic account to view the entire video.

Preview

Start a free Basic trial
to watch this video

Sign up for Treehouse

Types

7:58 with Jay McGavren

Values in C# are classified into different that specify what the values can be used for.

Declaring variables using the var keyword only works if you initialize the variable with a value, that is, assign a value to it immediately. If you don't, you'll get a syntax error saying "Implicitly-typed variables must be initialized".

var number;
var greeting;
System.Console.WriteLine(number);
System.Console.WriteLine(greeting);
System.Console.WriteLine(number + 2);

Program.cs(5,13): error CS0818: Implicitly-typed variables must be initialized [/home/treehouse/workspace/workspace.csproj]
Program.cs(6,13): error CS0818: Implicitly-typed variables must be initialized [/home/treehouse/workspace/workspace.csproj]

Values in C# are classified into different types that specify what the values can be used for. You can view the type of a value by calling the GetType() method on it. We haven't covered methods yet, but for now all you need to know is that a method is a collection of code which you can call to get it to do something. You call a method by putting a dot (that is, a period character), the method name, and a pair of parentheses after a value.

For whole numbers, the GetType() method gives a type of System.Int32. For strings of text surrounded by double quotes, GetType() gives a type of System.String.

System.Console.WriteLine(1.GetType());       // Prints "System.Int32"
System.Console.WriteLine(2.GetType());       // Prints "System.Int32"
System.Console.WriteLine(3.GetType());       // Prints "System.Int32"
System.Console.WriteLine("hello".GetType()); // Prints "System.String"
System.Console.WriteLine("hi".GetType());    // Prints "System.String"

C# has dozens of types built-in.

  • Integers, as we mentioned, have a type of System.Int32 by default.
  • Floating-point numbers, that is, numbers with a decimal point, have a type of System.Double by default.
  • The special values true and false have a type of System.Boolean.
  • Strings of text characters surrounded by double quotes, as we mentioned, have a type of System.String.
  • Individual characters of text surrounded by single quotes have a type of System.Char.
System.Console.WriteLine(4.GetType());       // Prints "System.Int32"
System.Console.WriteLine(3.1415.GetType());  // Prints "System.Double"
System.Console.WriteLine(true.GetType());    // Prints "System.Boolean"
System.Console.WriteLine("hello".GetType()); // Prints "System.String"
System.Console.WriteLine('z'.GetType());     // Prints "System.Char"

The type of a C# value specifies what you can do with it. You can do math with numbers. Or you can capitalize text...

System.Console.WriteLine(5 - 3);
System.Console.WriteLine("hello".ToUpper());

2
HELLO

But it doesn't make any sense to capitalize a number or do math with a string. And you'll get errors if you try.

System.Console.WriteLine(5.ToUpper());
System.Console.WriteLine("hello" - 3);

Program.cs(5,36): error CS1061: 'int' does not contain a definition for 'ToUpper' and no accessible extension method 'ToUpper' accepting a first argument of type 'int' could be found (are you missing a using directive or an assembly reference?) [/home/treehouse/workspace/workspace.csproj]
Program.cs(6,34): error CS0019: Operator '-' cannot be applied to operands of type 'string' and 'int' [/home/treehouse/workspace/workspace.csproj]

Those errors are actually a good thing. C# detects that you've made a mistake, and is letting you know about it, so you can fix the problem before users of your program see it. And the only reason C# can detect these kinds of errors is because of types. Types help protect you from making mistakes in your code.

In software development, this is known as type safety: the assurance that when you have a value of a particular type, you can do particular operations on it, and be certain those operations will work. Type safety is an important feature of the C# language.

System.Console.WriteLine(5 - 3);
System.Console.WriteLine("hello".ToUpper());

So now let's look again at that error we got when we declared a variable with the var keyword, but didn't assign it a value. "Implicitly-typed variables must be initialized..."

var number;
var greeting;
System.Console.WriteLine(number);
System.Console.WriteLine(greeting);
System.Console.WriteLine(number + 2);

Program.cs(5,13): error CS0818: Implicitly-typed variables must be initialized [/home/treehouse/workspace/workspace.csproj]
Program.cs(6,13): error CS0818: Implicitly-typed variables must be initialized [/home/treehouse/workspace/workspace.csproj]

Every variable in C# needs to have a type. When you use the var keyword, C# will look at the type of the value you're initializing the variable with, and use that as the type of the variable. That's what it means by "implicitly-typed"; the initial value implies that a variable should have a certain type. But if you don't provide an initial value, there's no way to determine what the variable's type should be, and you'll get an error.

var number = 4;
var greeting = "hi";
System.Console.WriteLine(number.GetType());
System.Console.WriteLine(greeting.GetType());

System.Int32
System.String

So how do you declare a variable without assigning an initial value? You give it an explicit type: you specify what type of value the variable should hold. Just write the type name followed by the variable name, and the variable is declared.

System.Int32 number;
System.String greeting;

Then you can assign a value to the variable later on, when you're ready to use it.

System.Int32 number;
System.String greeting;
number = 10;
greeting = "What's up?";
System.Console.WriteLine(greeting);
System.Console.WriteLine(number + 2);

If you want, you can initialize a variable with an explicit type declaration just like you can when using the var keyword:

System.Int32 number = 10;
System.String greeting = "What's up?";
System.Console.WriteLine(greeting);
System.Console.WriteLine(number + 2);

By the way, we did something a little unusual with the types for our variables, that C# developers don't normally do. When you call the GetType() method on most integers, you get System.Int32 back. For strings, GetType() returns System.String. To make the connection clear, we used System.Int32 and System.String as the types of our variables.

But typing System.Int32 and System.String all the time would get really tedious. So C# offers some shortcuts.

  • A type of int with a lower-case "i" is equivalent to System.Int32.
  • And a type of string with a lower-case "s" is equivalent to System.String.
int number = 10;
string greeting = "What's up?";
System.Console.WriteLine(number.GetType());
System.Console.WriteLine(greeting.GetType());
System.Console.WriteLine(greeting);
System.Console.WriteLine(number + 2);

System.Int32
System.String
What's up?
12
  • There are shortcuts for other frequently-used types, too.
  • Here's a program that uses variable declarations with explicit types for the same integer, floating-point number, boolean value, string, and character value that we saw earlier.
  • You can see we use types of System.Int32, System.Double, System.Boolean, System.String, and System.Char for the variables.
System.Int32 wholeNumber = 4;
System.Double pi = 3.1415;
System.Boolean status = true;
System.String greeting = "hello";
System.Char letter = 'z';

System.Console.WriteLine(wholeNumber.GetType());
System.Console.WriteLine(pi.GetType());
System.Console.WriteLine(status.GetType());
System.Console.WriteLine(greeting.GetType());
System.Console.WriteLine(letter.GetType());

System.Int32
System.Double
System.Boolean
System.String
System.Char

Each one of those types has an equivalent shortcut type name. I can replace the type in each variable declaration with its shortcut name, and the program will still work the same:

int wholeNumber = 4;
double pi = 3.1415;
bool status = true;
string greeting = "hello";
char letter = 'z';

System.Console.WriteLine(wholeNumber.GetType());
System.Console.WriteLine(pi.GetType());
System.Console.WriteLine(status.GetType());
System.Console.WriteLine(greeting.GetType());
System.Console.WriteLine(letter.GetType());

C# developers almost never use the full type names for these built-in types in their programs; they use the shortcuts instead. In your code, you should use lower-case shortcut names like int, double, bool, string, and char. But don't be surprised when the GetType() method returns the types System.Int32, System.Double, System.Boolean, System.String, and System.Char.

  • 0:00

    Declaring variables using the var keyword, only works if you initialize the variable

  • 0:04

    with a value, that is assign a value to it immediately.

  • 0:10

    If you don't, you'll get a syntax error saying,

  • 0:14

    implicitly-typed variables must be initialized.

  • 0:18

    So what does it mean, implicitly-typed variables?

  • 0:21

    Values in C# are classified into different types that specify

  • 0:25

    what the values can be used for.

  • 0:27

    You can view of a value by calling the GetType method on it.

  • 0:34

    We haven't covered methods yet.

  • 0:35

    But for now, all you need to know is that a method is a collection of code which you

  • 0:40

    can call to get it to do something.

  • 0:42

    You call a method by putting a dot, that's the period character,

  • 0:46

    the method name, and a pair of parentheses after a value.

  • 0:50

    For whole numbers, the GetType method gives a type of System.Int32.

  • 0:57

    For strings of text surrounded by double quotes,

  • 1:01

    GetType gives a type of System.String.

  • 1:07

    C# has dozens of types built in.

  • 1:10

    Integers, as we mentioned, have a type of System.Int32 by default.

  • 1:18

    Floating point numbers, that is, numbers with a decimal point,

  • 1:21

    have a type of System.Double by default.

  • 1:24

    The special values true and false has a type of System.Boolean.

  • 1:28

    Strings of text characters surrounded by double quotes,

  • 1:32

    as we mentioned, have a type of System.String.

  • 1:38

    And individual characters of text surrounded by single quotes have a type of

  • 1:43

    System.Char.

  • 1:46

    As we mentioned, types specify what a value can be used for.

  • 1:50

    To understand this, think about objects in the world around you.

  • 1:53

    You can read a book or a magazine because those are printed materials.

  • 1:58

    You can drink coffee or soda because those are beverages.

  • 2:01

    But if you try to drink a book or read coffee, it won't go very well.

  • 2:05

    Likewise, the type of a C# value specifies what you can do with it.

  • 2:10

    You can do math with numbers or you can capitalize text.

  • 2:15

    Likewise, the type of a C# value specifies what you can do with it,

  • 2:19

    you can do math with numbers or you can capitalize text.

  • 2:22

    But it does not make any sense to try to capitalize the number.

  • 2:29

    Nor does it make sense to do math with a string.

  • 2:33

    You'll get errors if you try.

  • 2:36

    Those errors are actually a good thing.

  • 2:38

    C# detects that you made a mistake, and is letting you know about it, so

  • 2:42

    you can fix the problem before users of your program see it.

  • 2:45

    And the only reason C# can detect these kinds of errors is because of types.

  • 2:50

    Types help protect you from making mistakes in your code.

  • 2:54

    In software development, this is known as type safety.

  • 2:57

    The assurance that when you have a value of a particular type,

  • 3:01

    you can do particular operations on it and be certain those operations will work.

  • 3:05

    Type safety is an important feature of the C# language.

  • 3:10

    So now let's look again at that error we got when we declared the variable with

  • 3:15

    the VAR keyword but didn't assign it a value.

  • 3:17

    It says implicitly type variables must be initialized.

  • 3:22

    Every variable in C# needs to have a type.

  • 3:25

    When you use the VAR keyword C# will look the type in the value your initialized

  • 3:30

    in the variable with, and use that as the type of the variable.

  • 3:34

    That's what it means by implicitly typed,

  • 3:37

    the initial value implies that variable should have a certain type.

  • 3:41

    But if you don't provide an initial value there's no way to

  • 3:44

    determine what the variables type should be, and that's when you'll get errors.

  • 3:54

    So how do you declare a variable without assigning an initial value?

  • 3:57

    You give it an explicit type,

  • 3:59

    you specify what type of value the variable should hold.

  • 4:03

    Just write the type name followed by the variable name and

  • 4:06

    the variable is declared.

  • 4:20

    Then you can assign a value to the variable later on when you're ready

  • 4:25

    to use it.

  • 4:26

    Let me try saving this and running it.

  • 4:31

    And you can see everything is working.

  • 4:34

    If you want, you can initialize a variable with an explicit type declaration

  • 4:38

    just like you can when you’re using the VAR keyword.

  • 4:41

    So let me edit these four statements together.

  • 4:45

    I'll delete my number = 10 assignment and say instead System.Int32 number = 10.

  • 4:52

    And I'll delete my what's up greeting assignment, And

  • 4:57

    instead, initialize the greeting variable with that value.

  • 5:01

    Let me save that, try rerunning it.

  • 5:07

    And I get the same result.

  • 5:12

    By the way, we did something a little unusual with the types for

  • 5:15

    our variables that C# developers don't normally do.

  • 5:18

    When you call the GetType method on those signatures, you get System.Int32 back.

  • 5:24

    For strings, you GetType return System.String.

  • 5:27

    Let me run this real quick so we can confirm that.

  • 5:31

    Oops I forgot to say first, let me say that.

  • 5:35

    And go back to the console and run it again.

  • 5:39

    There we go System.Int32 and System.String.

  • 5:44

    So to make the connection clear we use System.Int32 and

  • 5:47

    System.String is the types of our variables.

  • 5:50

    But typing System.Int32 and System.String all the time would get really tedious.

  • 5:56

    So C# offers some shortcuts.

  • 5:59

    A type of int with a lower case i is equivalent to System.Int32.

  • 6:04

    And a type of string with a lower case s is equivalent to System.String.

  • 6:09

    Let me save this, and let's try running that.

  • 6:15

    And you'll see we get the same result.

  • 6:17

    Int converts to System.Int32 and string converts to System.String.

  • 6:23

    There are shortcuts for other frequently used types too.

  • 6:26

    Here's a program that uses variable declarations with explicit types for

  • 6:30

    the same integer, floating point number, Boolean value, string and

  • 6:34

    character value that we saw earlier.

  • 6:36

    You can see that we use types of System.Int32,

  • 6:39

    System.Double, System.Boolen, System.String and System.Char.

  • 6:44

    Each one of those types has an equivalent shortcut type name.

  • 6:47

    I can replace the type in each variable declaration with it's shortcut name, and

  • 6:52

    the program will still work the same way.

  • 6:55

    So System.Int32 as we already demonstrated can be replace with lowercase int.

  • 7:02

    System.Double can be replace with lowercase double.

  • 7:07

    System.Boolean can be replaced with just bool.

  • 7:12

    System.String can be replaced by the single word string in lowercase.

  • 7:19

    And System.Char can be replaced with the abbreviation char in lowercase.

  • 7:25

    Let me save this and run it.

  • 7:29

    And you can see it still works and it prints the full names out for each type.

  • 7:33

    C# developers almost never use the full type names for

  • 7:37

    these built in types in their programs, they use shortcuts instead.

  • 7:42

    In your code you should use lowercase shortcut names like int,

  • 7:45

    double, bool, string, and char.

  • 7:48

    But don't be surprised when the GetType method returns the type System.Int32,

  • 7:53

    System.Double, System.Boolean, System.String, and System.Char.

You need to sign up for Treehouse in order to download course files.

Sign up