Programming workflow

The workflow of the programmer will differ a bit depending on if the program is written in a compiled or an intprepreted programming language. From the distance, both looks like what is pictured in the the flowchart demonstrating roles and tasks of a programmer, beta tester and user in the creation of programs, but some differences remain:

• Compiled language workflow
  • Writing down specifications
  • Creating the source code
  • Running the compiler
  • Reading the compiler’s output, warning and error messages
  • Fixing compile errors, if necessary
  • Executing and testing the program
  • Debugging the program, if necessary
• Interpreted language workflow
  • Writing down specifications
  • Creating the source code
  • Executing the program in the interpreter
  • Reading the interpreter’s output, determining if there is a syntax (language) error or the program finished executing
  • Editing the program to fix syntax errors
  • Testing the program (once it can execute with no errors)
  • Debugging the program, if necessary

Interperted languages have

• Advantages: Fewer steps between writing and executing, can be a faster cycle
• Disadvantages: All errors happen when you execute the program, no distinction between syntax errors (compile errors) and logic errors (bugs in executing program)

(Integrated) Development Environment

Programers can either use a collection of tools to write, compile, debug and execute a program, or use an “all-in-one” solution called an Integrated Development Environment (IDE).

• The “Unix philosophy” states that a program should do only one task, and do it properly. For programmers, this means that
  • One program will be needed to edit the source code, a text editor (it can be Geany, notepad, kwrite, emacs, sublime text, vi, etc.),
  • One program will be needed to compile the source code, a compiler (for C#, it will be either mono or Roslyn,
  • Other programs may be needed to debug, execute, or organize larger projects, such as makefile or MKBundle.

IDE “bundle” all of those functionality into a single interface, to ease the workflow of the programmer. This means sometimes that programmers have fewer control over their tools, but that it is easier to get started.

• Integrated Development Environment (IDE)
  • Combines a text editor, compiler, file browser, debugger, and other tools
  • Helps you organize a programming project
  • Helps you write, compile, and test code in one place

In particular, Visual Studio is an IDE, and it uses its own vocabulary:

• Solution: An entire software project, including source code, metadata, input data files, etc.
• “Build solution”: Compile all of your code
• “Start without debugging”: Execute the compiled code
• Solution location: The folder (on your computer’s file system) that contains the solution, meaning all your code and the information needed to compile and execute it

Hello World

/* I'm a multi-line comment,
 * I can span over multiple lines!
 */
using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, world!"); // I'm an in-line comment.
    }
}

Features of this program:

• A multi-line comment: everything between the /* and */ is considered a comment, i.e. text for humans to read. It will be ignored by the C# compiler and has no effect on the program.

• A using statement: This imports code definitions from the System namespace, which is part of the .NET Framework (the standard library).

  • In C#, code is organized into namespaces, which group related classes together
  • If you want to use code from a different namespace, you need a using statement to “import” that namespace
  • All the standard library code is in different namespaces from the code you will be writing, so you’ll need using statements to access it

• A class declaration²

  • Syntax:

   class [name of class]
   {
         [body of the class]
   }

  • All code between opening { and closing } is the body of the class named by the class [name of class] statement

• A method declaration

  • A collection of instructions with a name
  • Can be used by typing its name
  • A method is similar to a paragraph, in that it can contain multiple statements, and a class is similar to a chapter, in that it can have multiple methods within its body.
  • A C# program requires a method called Main, and, in our example, is followed by empty parentheses (we will get to those later, but they are required)
  • Just like the class declaration, the body of the method beings with { and ends with }

• A statement inside the body of the method:

  Console.WriteLine("Hello, world!"); // I'm an in-line comment.

  • This is the part of the program that actually “does something”: It displays a line of text to the console:

    

  • This statement contains a class name (Console), followed by a method name (WriteLine). It calls the WriteLine method in the Console class.

  • The argument to the WriteLine method is the text “Hello, world!”, which is in parentheses after the name of the method. This is the text that gets printed in the console: The WriteLine method (which is in the standard library) takes an argument and prints it to the console.

  • Note that the argument to WriteLine is inside double-quotes. This means it is a string, i.e. textual data, not a piece of C# code. The quotes are required in order to distinguish between text and code.

  • A statement must end in a semicolon (the class header and method header are not statements)

• An in-line comment: All the text from the // to the end of the line is considered a comment, and is ignored by the C# compiler.

Literals and their types

• A literal is a data value written in the code
• A form of “input” provided by the programmer rather than the user; its value is fixed throughout the program’s execution
• Literal data must have a type, indicated by syntax:
  • string literal: text in double quotes, like "hello"
  • char literal: a character in single quotes, like 'a'
  • int literal: a number without a decimal point, with or without a minus sign (e.g. 52)
  • long literal: just like an int literal but with the suffix l or L, e.g. 4L
  • double literal: a number with a decimal point, with or without a minus sign (e.g. -4.5)
  • float literal: just like a double literal but with the suffix f or F (for “float”), e.g. 4.5f
  • decimal literal: just like a double literal but with the suffix m or M(for “deciMal”), e.g. 6.01m

Variables overview

• Variables store data that can vary (change) during the program’s execution

• They have a type, just like literals, and also a name

• You can use literals to write data that gets stored in variables

• Sample program with variables:

  using System;
  
  class MyFirstVariables
  {
      static void Main()
      {
          // Declaration
          int myAge;
          string myName;
          // Assignment
          myAge = 29;
          myName = "Edward";
          // Displaying
          Console.WriteLine($"My name is {myName} and I am {myAge} years old.");
      }
  }

  This program shows three major operations you can do with variables.

  • First it declares two variables, an int-type variable named “myAge” and a string-type variable named “myName”
  • Then, it assigns values to each of those variables, using literals of the same type. myAge is assigned the value 29, using the int literal 29, and myName is assigned the value “Edward”, using the string literal "Edward"
  • Finally, it displays the current value of each variable by using the Console.WriteLine method and string interpolation, in which the values of variables are inserted into a string by writing their names with some special syntax (a $ character at the beginning of the string, and braces around the variable names)

Declaration

• This is when you specify the name of a variable and its type
• The syntax is the type keyword, a space, the name of the variable, then a semi-colon.
• Examples: int myAge;, string myName;, double winChance;.
• A variable name is an identifier, so it should follow the rules and conventions
  • Can only contain letters and numbers
  • Must be unique among all variable, method, and class names
  • Should use CamelCase if it contains multiple words
• Note that the variable’s type is not part of its name: two variables cannot have the same name even if they are different types
• Multiple variables can be declared in the same statement: string myFirstName, myLastName; would declare two strings called respectively myFirstName and myLastName

Assignment

• The act of changing the value of a variable
• Uses the symbol =, which is the assignment operator, not a statement of equality – it does not mean “equals”
• Direction of assignment is right to left: the variable goes on the left side of the = symbol, and its new value goes on the right
• Syntax: variable_name = value;
• Example: myAge = 29;
• Value must match the type of the variable. If myAge was declared as an int-type variable, you cannot write myAge = "29"; because "29" is a string

Initialization (Declaration + Assignment)

• Initialization statement combines declaration and assignment in one single statement (it is just a shortcut, a.k.a. some “syntactical sugar”, and not something new)
• Creates a new variable and also gives it an initial value
• The syntax is the datatype of the variable, the name of the variable, the = sign, the value we want to store, and a semi-colon
• Example: string myName = "Edward";
• Can only be used once per variable, since you can only declare a variable once

Assignment Details

• Assignment replaces the “old” value of the variable with a “new” one; it is how variables vary

  • If you initialize a variable with int myAge = 29; and then write myAge = 30;, the variable myAge now stores the value 30

• You can assign a variable to another variable: just write a variable name on both sides of the = operator

  • This will take a “snapshot” of the current value of the variable on the right side, and store it into the variable on the left side

  • For example, in this code:

    int a = 12;
    int b = a;
    a = -5;

    the variable b gets the value 12, because that’s the value that a had when the statement int b = a was executed. Even though a was then changed to -5 afterward, b is still 12.

Displaying

• Only text (strings) can be displayed in the console
• When we want to print a mixture of text and variables with Console.WriteLine, we need to convert all of them to a string
• String interpolation: a mechanism for converting a variable’s value to a string and inserting it into the main string
  • Syntax: $"text {variable} text" – begin with a $ symbol, then put variable’s name inside brackets within the string
  • Example: $"I am {myAge} years old"
  • When this line of code is executed, it reads the variable’s current value, converts it to a string (29 becomes "29"), and inserts it into the surrounding string
  • Displayed: I am 29 years old
• If the argument to Console.WriteLine is the name of a variable, it will automatically convert that variable to a string before displaying it
• For example, Console.WriteLine(myAge); will display “29” in the console, as if we had written Console.WriteLine($"{myAge}");
• When string interpolation converts a variable to a string, it must call a “string conversion” method supplied with the data type (int, double, etc.). All built-in C# datatypes come with string conversion methods, but when you write your own data types (classes), you’ll need to write your own string conversions – string interpolation will not magically “know” how to convert MyClass variables to strings

On a final note, observe that you can write statements mixing multiple declarations and assignments, as in int myAge = 10, yourAge, ageDifference; that declares three variables of type int and set the value of the first one. It is generally recommended to separate those instructions in different statements as you begin, to ease debugging and have a better understanding of the “atomic steps” your program should perform.

Sizes of Numeric Datatypes

• Numeric datatypes have different sizes
• Amount of memory used/reserved by each variable depends on the variable’s type
• Amount of memory needed for an integer data type depends on the size of the number
  • int uses 4 bytes of memory, can store numbers in the range [−2³¹,2³¹−1]
  • long uses 8 bytes of memory can store numbers in the range [−2⁶³,2⁶³−1]
  • short uses 2 bytes of memory, can store numbers in the range [−2¹⁵,2¹⁵−1]
  • sbyte uses only 1 bytes of memory, can store numbers in the range [−128,127]
• Unsigned versions of the integer types use the same amount of memory, but can store larger positive numbers
  • byte uses 1 byte of memory, can store numbers in the range [0,255]
  • ushort uses 2 bytes of memory, can store numbers in the range [0,2¹⁶−1]
  • uint uses 4 bytes of memory, can store numbers in the range [0,2³²−1]
  • ulong uses 8 bytes of memory, can store numbers in the range [0,2⁶⁴−1]
  • This is because in a signed integer, one bit (digit) of the binary number is needed to represent the sign (+ or -). This means the actual number stored must be 1 bit smaller than the size of the memory (e.g. 31 bits out of the 32 bits in 4 bytes). In an unsigned integer, there is no “sign bit”, so all the bits can be used for the number.
• Amount of memory needed for a floating-point data type depends on the precision (significant figures) of the number
  • float uses 4 bytes of memory, can store positive or negative numbers in a range of approximately [10⁻⁴⁵,10³⁸], with 7 significant figures of precision
  • double uses 8 bytes of memory, and has both a wider range (10⁻³²⁴ to 10³⁰⁸) and more significant figures (15 or 16)
  • decimal uses 16 bytes of memory, and has 28 or 29 significant figures of precision, but it actually has the smallest range (10⁻²⁸ to 10²⁸) because it stores decimal fractions exactly
• Difference between binary fractions and decimal fractions
  • float and double store their data as binary (base 2) fractions, where each digit represents a power of 2
    • The binary number 101.01 represents 4 + 1 + 1/4, or 5.25 in base 10
  • More specifically, they use binary scientific notation: A mantissa (a binary integer), followed by an exponent assumed to be a power of 2, which is applied to the mantissa
    • 10101e-10 means a mantissa of 10101 (i.e. 21 in base 10) with an exponent of -10 (i.e. 2⁻² in base 10), which also produces the value 101.01 or 5.25 in base 10
  • Binary fractions cannot represent all base-10 fractions, because they can only represent fractions that are negative powers of 2. 1/10 is not a negative power of 2 and cannot be represented as a sum of 1/16, 1/32, 1/64, etc.
  • This means some base-10 fractions will get “rounded” to the nearest finite binary fraction, and this will cause errors when they are used in arithmetic
  • On the other hand, decimal stores data as a base-10 fraction, using base-10 scientific notation
  • This is slower for the computer to calculate with (since computers work only in binary) but has no “rounding errors” with fractions that include 0.1
  • Use decimal when working with money (since money uses a lot of 0.1 and 0.01 fractions), double when working with non-money fractions

Summary of numeric data types and sizes:

Value and Reference types

• Value and reference types are different ways of storing data in memory

• Variables name memory locations, but the data that gets stored at the named location is different for each type

• For a value type variable, the named memory location stores the exact data value held by the variable (just what you’d expect)

• Value types: all the numeric types (int, float, double, decimal, etc.), char, and bool

• For a reference type variable, the named memory location stores a reference to the data, not the data itself

  • The contents of the memory location named by the variable are the address of another memory location
  • The other memory location is where the variable’s data is stored
  • To get to the data, the computer first reads the location named by the variable, then uses that information (the memory address) to find and read the other memory location where the data is stored

• Reference types: string, object, and all objects you create from your own classes

• Assignment works differently for reference types

  • Assignment always copies the value in the variable’s named memory location - but in the case of a reference type that’s just a memory address, not the data

  • Assigning one reference-type variable to another copies the memory address, so now both variables “refer to” the same data

  • Example:

    string word = "Hello";
    string word2 = word;

    Both word and word2 contain the same memory address, pointing to the same memory location, which contains the string “Hello”. There is only one copy of the string “Hello”; word2 does not get its own copy.

Arithmetic and variables

• The result of an arithmetic expression (like those shown in the table) is a numeric value

  • For example, the C# expression 3 * 4 has the value 12, which is int data

• A numeric value can be assigned to a variable of the same type, just like a literal: int myVar = 3 * 4; initializes the variable myVar to contain the value 12

• A numeric-type variable can be used in an arithmetic expression

• When a variable is used in an arithmetic expression, its current value is read, and the math is done on that value

• Example:

  int a = 4;
  int b = a + 5;
  a = b * 2;

  • To execute the second line of the code, the computer will first evaluate the expression on the right side of the = sign. It reads the value of the variable a, which is 4, and then computes the result of 4 + 5, which is 9. Then, it assigns this value to the variable b (remember assignment goes right to left).
  • To execute the third line of code, the computer first evaluates the expression on the right side of the = sign, which means reading the value of b to use in the arithmetic operation. b contains 9, so the expression is 9 * 2, which evaluates to 18. Then it assigns the value 18 to the variable a, which now contains 18 instead of 4.

• A variable can appear on both sides of the = sign, like this:

  int myVar = 4;
  myVar = myVar * 2;

  This looks like a paradox because myVar is assigned to itself, but it has a clear meaning because assignment is evaluated right to left. When executing the second line of code, the computer evaluates the right side of the = before doing the assignment. So it first reads the current (“old”) value of myVar, which is 4, and computes 4 * 2 to get the value 8. Then, it assigns the new value to myVar, overwriting its old value.

Compound assignment operators

• The pattern of “compute an expression with a variable, then assign the result to that variable” is common, so there are shortcuts for doing it
• The compound assignment operators change the value of a variable by adding, subtracting, etc. from its current value, equivalent to an assignment statement that has the value on both sides:

Assignments from different types

• The “proper” way to initialize a variable is to assign it a literal of the same type:

  int myAge = 29;
  double myHeight = 1.77;
  float radius = 2.3f;

  Note that 1.77 is a double literal, while 2.3f is a float literal

• If the literal is not the same type as the variable, you will sometimes get an error – for example, float radius = 2.3 will result in a compile error – but sometimes, it appears to work fine: for example float radius = 2; compiles and executes without error even though 2 is an int value.

• In fact, the value being assigned to the variable must be the same type as the variable, but some types can be implicitly converted to others

Implicit conversions

• Implicit conversion allows variables to be assigned from literals of the “wrong” type: the literal value is first implicitly converted to the right type

  • In the statement float radius = 2;, the int value 2 is implicitly converted to an equivalent float value, 2.0f. Then the computer assigns 2.0f to the radius variable.

• Implicit conversion also allows variables to be assigned from other variables that have a different type:

  int length = 2;
  float radius = length;

When the computer executes the second line of this code, it reads the variable length to get an int value 2. It then implicitly converts that value to 2.0f, and then assigns 2.0f to the float-type variable radius.

• Implicit conversion only works between some data types: a value will only be implicitly converted if it is “safe” to do so without losing data

• Summary of possible implicit conversions:

  Type	Possible Implicit Conversions
  short	int, long, float, double, decimal
  int	long, float, double, decimal
  long	float, double, decimal
  ushort	uint, int, ulong, long, decimal, float, double
  uint	ulong, long, decimal, float, double
  ulong	decimal, float, double
  float	double

• In general, a data type can only be implicitly converted to one with a larger range of possible values

• Since an int can store any integer between  − 2³¹ and 2³¹ − 1, but a float can store any integer between  − 3.4 × 10³⁸ and 3.4 × 10³⁸ (as well as fractional values), it is always safe to store an int value in a float

• You cannot implicitly convert a float to an int because an int stores fewer values than a float – it cannot store fractions – so converting a float to an int will lose data

• Note that all integer data types can be implicitly converted to float or double

• Each integer data type can be implicitly converted to a larger integer type: short → int → long

• Unsigned integer data types can be implicitly converted to a larger signed integer type, but not the same signed integer type: uint → long, but not uint → int

  • This is because of the “sign bit”: a uint can store larger values than an int because it does not use a sign bit, so converting a large uint to an int might lose data

Explicit conversions

• Any conversion that is “unsafe” because it might lose data will not happen automatically: you get a compile error if you assign a double variable to a float variable

• If you want to do an unsafe conversion anyway, you must perform an explicit conversion with the cast operator

• Cast operator syntax: ([type name]) [variable or value] – the cast is “right-associative”, so it applies to the variable to the right of the type name

• Example: (float) 2.8 or (int) radius

• Explicit conversions are often used when you (the programmer) know the conversion is actually “safe” – data will not actually be lost

  • For example, in this code, we know that 2.886 is within the range of a float, so it is safe to convert it to a float:

    float radius = (float) 2.886;

    The variable radius will be assigned the value 2.886f.

  • For example, in this code, we know that 2.0 is safe to convert to an int because it has no fractional part:

    double length = 2.0;
    int height = (int) length;

    The variable height will be assigned the value 2.

• Explicit conversions only work if there exists code to perform the conversion, usually in the standard library. The cast operator isn’t “magic” – it just calls a method that is defined to convert one type of data (e.g. double) to another (e.g. int).

  • All the C# numeric types have explicit conversions to each other defined
  • string does not have explicit conversions defined, so you cannot write int myAge = (int) "29";

• If the explicit conversion is truly unsafe (will lose data), data is lost in a specific way

  • Casting from floating-point (e.g. double) types to integer types: fractional part of number is truncated (ignored/dropped)

  • In int length = (int) 2.886;, the value 2.886 is truncated to 2 by the cast to int, so the variable length gets the value 2.

  • Casting from more-precise to less-precise floating point type: number is rounded to nearest value that fits in less-precise type:

    decimal myDecimal = 123456789.999999918m;
    double myDouble = (double) myDecimal;
    float myFloat = (float) myDouble;

    In this code, myDouble gets the value 123456789.99999993, while myFloat gets the value 123456790.0f, as the original decimal value is rounded to fit types with fewer significant figures of precision.

  • Casting from a larger integer to a smaller integer: the most significant bits are truncated – remember that numbers are stored in binary format

  • This can cause weird results, since the least-significant bits of a number in binary do not correspond to the least significant digits of the equivalent base-10 number

  • Casting from another floating point type to decimal: Either value is stored precisely (no rounding), or program crashes with System.OverflowException if value is larger than decimal’s maximum value:

    decimal fromSmall = (decimal) 42.76875;
    double bigDouble = 2.65e35;
    decimal fromBig = (decimal) bigDouble;

    In this code, fromSmall will get the value 42.76875m, but the program will crash when attempting to cast bigDouble to a decimal because 2.65 × 10³⁵ is larger than decimal’s maximum value of 7.9 × 10²⁸

  • decimal is more precise than the other two floating-point types (thus does not need to round), but has a smaller range (only 10²⁸, vs. 10³⁰⁸)

Summary of implicit and explicit conversions for the numeric datatypes:

Refer to the “Result Type of Operations” chart from the cheatsheet for more detail.

Implicit conversions in math

• If the two operands/arguments to a math operator are not the same type, they must become the same type – one must be converted
• C# will first try implicit conversion to “promote” a less-precise or smaller value to a more precise, larger type
• Example: with the expression double fracDiv = 21 / 2.4;
  • Operand types are int and double
  • int is smaller/less-precise than double
  • 21 gets implicitly converted to 21.0, a double value
  • Now the operands are both double type, so the double version of the / operator gets executed
  • The result is 8.75, a double value, which gets assigned to the variable fracDiv
• Implicit conversion also happens in assignment statements, which happen after the math expression is computed
• Example: with the expression double fraction = 21 / 5;
  • Operand types are int and int
  • Since they match, the int version of / gets executed
  • The result is 4, an int value
  • Now this value is assigned to the variable fraction, which is double type
  • The int value is implicitly converted to the double value 4.0, and fraction is assigned the value 4.0

Explicit conversions in math

• If the operands are int type, the int version of / will get called, even if you assign the result to a double

• You can “force” floating-point division by explicitly converting one operand to double or float

• Example:

  int numCookies = 21;
  int numPeople = 6;
  double share = (double) numCookies / numPeople;

  Without the cast, share would get the value 3.0 because numCookies and numPeople are both int type (just like the fraction example above). With the cast, numCookies is converted to the value 21.0 (a double), which means the operands are no longer the same type. This will cause numPeople to be implicitly converted to double in order to make them match, and the double version of / will get called to evaluate 21.0 / 6.0. The result is 3.5, so share gets assigned 3.5.

• You might also need a cast to ensure the operands are the same type, if implicit conversion does not work

• Example:

  decimal price = 3.89;
  double shares = 47.75;
  decimal total = price * (decimal) shares;

  In this code, double cannot be implicitly converted to decimal, and decimal cannot be implicitly converted to double, so the multiplication price * shares would produce a compile error. We need an explicit cast to decimal to make both operands the same type (decimal).

Parsing user input

• Console.ReadLine() always returns the same type of data, a string, regardless of what the user enters

  • If you ask the user to enter a number, ReadLine will output that number as a string
  • For example, if you ask the user to enter his/her age, and the user enters 21, Console.ReadLine() will return the string "21"

• If we want to do any kind of arithmetic with a number provided by the user, we will need to convert that string to a numeric type like int or double. Remember that casting cannot be used to convert numeric data to or from string data.

• When converting numeric data to string data, we use string interpolation:

  int myAge = 29;
  //This does not work:
  //string strAge = (string) myAge;
  string strAge = $"{myAge}";

• In the other direction, we use a method called Parse to convert strings to numbers:

  string strAge = "29";
  //This does not work:
  //int myAge = (int) strAge;
  int myAge = int.Parse(strAge);

• The int.Parse method takes a string as an argument, and returns an int containing the numeric value written in that string

• Each built-in numeric type has its own Parse method

  • int.Parse("42") returns the value 42
  • long.Parse("42") returns the value 42L
  • double.Parse("3.65") returns the value 3.65
  • float.Parse("3.65") returns the value 3.65f
  • decimal.Parse("3.65") returns the value 3.65m

• The Parse methods are useful for converting user input to useable data. For example, this is how to get the user’s age as an int:

  Console.WriteLine("Enter your age:");
  string ageString = Console.ReadLine();
  int age = int.Parse(ageString);

More detail on the Parse methods

• Console.WriteLine is a method that takes input from your program, in the form of an argument, but does not return any output. Meanwhile, Console.ReadLine is a method that does not have any arguments, but it returns output to your program (the user’s string).

• int.Parse is a method that both takes input (the string argument) and returns output (the converted int value)

• When executing a statement such as

  int answer = int.Parse("42");

  the computer must evaluate the expression on the right side of the = operator before it can do the assignment. This means it calls the int.Parse method with the string "42" as input. The method’s code then executes, converting "42" to an integer, and it returns a result, the int value 42. This value can now be assigned to the variable answer.

• Since the return value of a Parse method is a numeric type, it can be used in arithmetic expressions just like a numeric-type variable or literal. For example, in this statement:

  double result = double.Parse("3.65") * 4;

  To evaluate the expression on the right side of the = operator, the computer must first call the method double.Parse with the input "3.65". Then the method’s return value, 3.65, is used the math operation as if it was written 3.65 * 4. So the computer implicitly converts 4 to a double value, performs the multiplication on doubles, and gets the resulting value 14.6, which it assigns to the variable result.

• Another example of using the result of Parse to do math:

  Console.WriteLine("Please enter the year.");
  string userInput = Console.ReadLine();
  int curYear = int.Parse(userInput);
  Console.WriteLine($"Next year it will be {curYear + 1}");

  Note that in order to do arithmetic with the user’s input (i.e. add 1), it must be a numeric type (i.e. int), not a string. This is why we often call a Parse method on the data returned by Console.ReadLine().

• The previous example can be made shorter and simpler by combining the Parse and ReadLine methods in one statement. Specifically, you can write:

  int curYear = int.Parse(Console.ReadLine());

  In this statement, the return value (output) of one method is used as the argument (input) to another method. When the computer executes the statement, it starts by evaluating the int.Parse(...) method call, but it cannot actually execute the Parse method yet because its argument is an expression, not a variable or value. In order to determine what value to send to the Parse method as input, it must first evaluate the Console.ReadLine() method call. Since this method has no arguments, the computer can immediately start executing it; the ReadLine method waits for the user to type a line of text, then returns that text as a string value. This return value can now be used as the argument to int.Parse, and the computer starts executing int.Parse with the user-provided string as input. When the Parse method returns an int value, this value becomes the value of the entire expression int.Parse(Console.ReadLine()), and the computer assigns it to the variable curYear.

• Notice that by placing the call to ReadLine inside the argument to Parse, we have eliminated the variable userInput entirely. The string returned by ReadLine does not need to be stored anywhere (i.e. in a variable); it only needs to exist long enough to be sent to the Parse method as input.

Correct input formatting

• The Parse methods assume that the string they are given as an argument (i.e. the user input) actually contains a valid number. But the user may not follow directions, and invalid input can cause a variety of errors.
• If the string does not contain a number at all – e.g. int badIdea = int.Parse("Hello"); – the program will fail with the error System.FormatException
• If the string contains a number with a decimal point, but the Parse method is for an integer datatype, the program will also fail with System.FormatException. For example, int fromFraction = int.Parse("52.5"); will cause this error. This will happen even if the number in the string ends in “.0” (meaning it has no fractional part), such as int wholeNumber = int.Parse("45.0");.
• If the string has extraneous text before or after the number, such as "$18.95" or 1999!, the program will fail with the error System.FormatException
• If the string contains a number that cannot fit in the desired datatype (due to overflow or underflow), the behavior depends on the datatype:
  • For the integer types (int and long), the program will fail with the error System.OverflowException. For example, int.Parse("3000000000") will cause this error because 3000000000 is larger than 2³¹ − 1 (the maximum value an int can store).
  • For the floating-point types (float and double), no error will be produced. Instead, the result will be the same as if an overflow or underflow had occurred during normal program execution: an overflow will produce the value Infinity, and an underflow will produce the value 0. For example, float tooSmall = float.Parse("1.5e-55"); will assign tooSmall the value 0, while double tooBig = double.Parse("1.8e310"); will assign tooBig the value double.Infinity.
• Acceptable string formats vary slightly between the numeric types, due to the different ranges of values they can contain
  • int.Parse and long.Parse will accept strings in the format ([ws])([sign])[digits]([ws]), where [ws] represents empty spaces and groups in parentheses are optional. This means that a string with leading or trailing spaces will not cause an error, unlike a string with other extraneous text around the number.
  • decimal.Parse will accept strings in the format ([ws])([sign])([digits],)[digits](.[digits])([ws]). Note that you can optionally include commas between groups of digits, and the decimal point is also optional. This means a string like "18,999" is valid for decimal.Parse but not for int.Parse.
  • float.Parse and double.Parse will accept strings in the format ([ws])([sign])([digits],)[digits](.[digits])(e[sign][digits])([ws]). As with decimal, you can include commas between groups of digits. In addition, you can write the string in scientific notation with the letter “e” or “E” followed by an exponent, such as "-9.44e15".

Converting from numbers to strings

• As we saw in a previous lecture (Datatypes and Variables), the Console.WriteLine method needs a string as its argument

• If the variable you want to display is not a string, you might think you could cast it to a string, but that will not work – there is no explicit conversion from string to numeric types

  • This code:

    double fraction = (double) 47 / 6;
    string text = (string) fraction;

    will produce a compile error

• You can convert numeric data to a string using string interpolation, which we’ve used before in Console.WriteLine statements:

  int x = 47, y = 6;
  double fraction = (double) x / y;
  string text = $"{x} divided by {y} is {fraction}";

  After executing this code, text will contain “47 divided by 6 is 7.8333333”

• String interpolation can convert any expression to a string, not just a single variable. For example, you can write:

  Console.WriteLine($"{x} divided by {y} is {(double) x / y}");
  Console.WriteLine($"{x} plus 7 is {x + 7}");

  This will display the following output:

  47 divided by 6 is 7.8333333
  47 plus 7 is 54

  Note that writing a math expression inside a string interpolation statement does not change the values of any variables. After executing this code, x is still 47, and y is still 6.

The ToString() method

• String interpolation does not “magically know” how to convert numbers to strings – it delegates the task to the numbers themselves

• This works because all data types in C# are objects, even the built-in ones like int and double

  • Since they are objects, they can have methods

• All objects in C# are guaranteed to have a method named ToString(), whose return value (result) is a string

• Meaning of ToString() method: “Convert this object to a string, and return that string”

• This means you can call the ToString() method on any variable to convert it to a string, like this:

  int num = 42;
  double fraction = 33.5;
  string intText = num.ToString();
  string fracText = fraction.ToString();

  After executing this code, intText will contain the string “42”, and fracText will contain the string “33.5”

• String interpolation calls ToString() on each variable or expression within braces, asking it to convert itself to a string

  • In other words, these three statements are all the same:

    Console.WriteLine($"num is {num}");
    Console.WriteLine($"num is {intText}");
    Console.WriteLine($"num is {num.ToString()}");

    Putting num within the braces is the same as calling ToString() on it.

Output with concatenation

• We now have two different ways to construct a string for Console.WriteLine: Interpolation and concatenation

• Concatenating a string with a variable will automatically call its ToString() method, just like interpolation will. These two WriteLine calls are equivalent:

  int num = 42;
  Console.WriteLine($"num is {num}");
  Console.WriteLine("num is " + num);

• It’s usually easier to use interpolation, since when you have many variables the + signs start to add up. Compare the length of these two equivalent lines of code:

  Console.WriteLine($"The variables are {a}, {b}, {c}, {d}, and {e}");
  Console.WriteLine("The variables are " + a + ", " + b + ", " + c + ", " + d + ", and " + e);

• Be careful when using concatenation with numeric variables: the meaning of + depends on the types of its two operands

  • If both operands are numbers, the + operator does addition

  • If both operands are strings, the + operator does concatenation

  • If one argument is a string, the other argument will be converted to a string using ToString()

  • Expressions in C# are always evaluated left-to-right, just like arithmetic

  • Therefore, in this code:

    int var1 = 6, var2 = 7;
    Console.WriteLine(var1 + var2 + " is the result");
    Console.WriteLine("The result is " + var1 + var2);

    The first WriteLine will display “13 is the result”, because var1 and var2 are both ints, so the first + operator performs addition on two ints (the resulting number,13, is then converted to a string for the second + operator). However, the second WriteLine will display “The result is 67”, because both + operators perform concatenation: The first one concatenates a string with var1 to produce a string, and then the second one concatenates this string with var2

  • If you want to combine addition and concatenation in the same line of code, use parentheses to make the order and grouping of operations explicit. For example:

    int var1 = 6, var2 = 7;
    Console.WriteLine((var1 + var2) + " is the result");
    Console.WriteLine("The result is " + (var1 + var2));

    In this code, the parentheses ensure that var1 + var2 is always interpreted as addition.

Accessing object members

• The “dot operator” that we use to call methods is technically the member access operator

• A member of an object is either a method or an instance variable

• When we write objectName.methodName(), e.g. rect1.SetLength(12), we are using the dot operator to access the “SetLength” member of rect1, which is a method; this means we want to call (execute) the SetLength method of rect1

• We can also use the dot operator to access instance variables, although we usually do not do that because of encapsulation

• If we wrote the Rectangle class like this:

  class Rectangle
  {
      public int length;
      public int width;
  }

  Then we could write a Main method that uses the dot operator to access the length and width instance variables, like this:

  static void Main(string[] args)
  {
      Rectangle rect1 = new Rectangle();
      rect1.length = 12;
      rect1.width = 3;
  }

  But this code violates encapsulation, so we will not do this.

Method calls in more detail

• Now that we know about the member access operator, we can explain how method calls work a little better

• When we write rect1.SetLength(12), the SetLength method is executed with rect1 as the calling object – we are accessing the SetLength member of rect1 in particular (even though every Rectangle has the same SetLength method)

• This means that when the code in SetLength uses an instance variable, i.e. length, it will automatically access rect1’s copy of the instance variable

• You can imagine that the SetLength method “changes” to this when you call rect1.SetLength():

  public void SetLength(int lengthParameter)
  {
      rect1.length = lengthParameter;
  }

  Note that we use the “dot” (member access) operator on rect1 to access its length instance variable.

• Similarly, you can imagine that the SetLength method “changes” to this when you call rect2.SetLength():

  public void SetLength(int lengthParameter)
  {
      rect2.length = lengthParameter;
  }

• The calling object is automatically “inserted” before any instance variables in a method

• The keyword this is an explicit reference to “the calling object”

  • Instead of imagining that the calling object’s name is inserted before each instance variable, you could write the SetLength method like this:

    public void SetLength(int lengthParameter)
    {
        this.length = lengthParameter;
    }

  • This is valid code (unlike our imaginary examples) and will work exactly the same as our previous way of writing SetLength

  • When SetLength is called with rect1.SetLength(12), this becomes equal to rect1, just like lengthParameter becomes equal to 12

  • When SetLength is called with rect2.SetLength(7), this becomes equal to rect2 and lengthParameter becomes equal to 7

Methods and instance variables

• Using a variable in an expression means reading its value

• A variable only changes when it is on the left side of an assignment statement; this is writing to the variable

• A method that uses instance variables in an expression, but does not assign to them, will not modify the object

• For example, consider the ComputeArea method:

  public int ComputeArea()
  {
      return length * width;
  }

  It reads the current values of length and width to compute their product, but the product is returned to the method’s caller. The instance variables are not changed.

• After executing the following code:

  Rectangle rect1 = new Rectangle();
  rect1.SetLength(12);
  rect1.SetWidth(3);
  int area = rect1.ComputeArea();

  rect1 has a length of 12 and a width of 3. The call to rect1.ComputeArea() computes 12 ⋅ 3 = 36, and the area variable is assigned this return value, but it does not change rect1.

Methods and return values

• Recall the basic structure of a program: receive input, compute something, produce output

• A method has the same structure: it receives input from its parameters, computes by executing the statements in its body, then produces output by returning a value

  • For example, consider this method defined in the Rectangle class:

    public int LengthProduct(int factor)
    {
        return length * factor;
    }

    Its input is the parameter factor, which is an int. In the method body, it computes the product of the rectangle’s length and factor. The method’s output is the resulting product.

• The return statement specifies the output of the method: a variable, expression, etc. that produces some value

• A method call can be used in other code as if it were a value. The “value” of a method call is the method’s return value.

  • In previous examples, we wrote int area = rect1.ComputeArea();, which assigns a variable (area) a value (the return value of ComputeArea())

  • The LengthProduct method can be used like this:

    Rectangle rect1 = new Rectangle();
    rect1.SetLength(12);
    int result = rect1.LengthProduct(2) + 1;

    When executing the third line of code, the computer first executes the LengthProduct method with argument (input) 2, which computes the product 12 ⋅ 2 = 24. Then it uses the return value of LengthProduct, which is 24, to evaluate the expression rect1.LengthProduct(2) + 1, producing a result of 25. Finally, it assigns the value 25 to the variable result.

• When writing a method that returns a value, the value in the return statement must be the same type as the method’s return type

  • If the value returned by LengthProduct is not an int, we will get a compile error

  • This will not work:

    public int LengthProduct(double factor)
    {
        return length * factor;
    }

    Now that factor has type double, the expression length * factor will need to implicitly convert length from int to double in order to make the types match. Then the product will also be a double, so the return value does not match the return type (int).

  • We could fix it by either changing the return type of the method to double, or adding a cast to int to the product so that the return value is still an int

• Not all methods return a value, but all methods must have a return type

  • The return type void means “nothing is returned”

  • If your method does not return a value, its return type must be void. If the return type is not void, the method must return a value.

  • This will cause a compile error because the method has a return type of int but no return statement:

    public int SetLength(int lengthP)
    {
        length = lengthP;
    }

  • This will cause a compile error because the method has a return type of void, but it attempts to return something anyway:

    public void GetLength()
    {
        return length;
    }

Instance variables vs. local variables

• Instance variables: Stored (in memory) with the object, shared by all methods of the object. Changes made within a method persist after method finishes executing.

• Local variables: Visible to only one method, not shared. Disappear after method finishes executing. Variables we’ve created before in the Main method (they are local to the Main method!).

• Example: In class Rectangle, we have these two methods:

  public void SwapDimensions()
  {
      int temp = length;
      length = width;
      width = temp;
  }
  public int GetLength()
  {
      return length;
  }

  • temp is a local variable within SwapDimensions, while length and width are instance variables
  • The GetLength method cannot use temp; it is visible only to SwapDimensions
  • When SwapDimensions changes length, that change is persistent – it will still be different when GetLength executes, and the next call to GetLength after SwapDimensions will return the new length
  • When SwapDimensions assigns a value to temp, it only has that value within the current call to SwapDimensions – after SwapDimensions finishes, temp disappears, and the next call to SwapDimensions creates a new temp

Definition of scope

• Variables exist only in limited time and space within the program

• Outside those limits, the variable cannot be accessed – e.g. local variables cannot be accessed outside their method

• Scope of a variable: The region of the program where it is accessible/visible

  • A variable is “in scope” when it is accessible
  • A variable is “out of scope” when it does not exist or cannot be accessed

• Time limits to scope: Scope begins after the variable has been declared

  • This is why you cannot use a variable before declaring it

• Space limits to scope: Scope is within the same code block where the variable is declared

  • Code blocks are defined by curly braces: everything between matching { and } is in the same code block
  • Instance variables are declared in the class’s code block (they are inside class Rectangle’s body, but not inside anything else), so their scope extends to the entire class
  • Code blocks nest: A method’s code block is inside the class’s code block, so instance variables are also in scope within each method’s code block
  • Local variables are declared inside a method’s code block, so their scope is limited to that single method

• The scope of a parameter (which is a variable) is the method’s code block - it is the same as a local variable for that method

• Scope example:

  public void SwapDimensions()
  {
      int temp = length;
      length = width;
      width = temp;
  }
  public void SetWidth(int widthParam)
  {
      int temp = width;
      width = widthParam;
  }

  • The two variables named temp have different scopes: One has a scope limited to the SwapDimensions method’s body, while the other has a scope limited to the SetWidth method’s body
  • This is why they can have the same name: variable names must be unique within the variable’s scope. You can have two variables with the same name if they are in different scopes.
  • The scope of instance variables length and width is the body of class Rectangle, so they are in scope for both of these methods

Variables with overlapping scopes

• This code is legal (compiles) but does not do what you want:

  class Rectangle
  {
      private int length;
      private int width;
      public void UpdateWidth(int newWidth)
      {
          int width = 5;
          width = newWidth;
      }
  }

• The instance variable width and the local variable width have different scopes, so they can have the same name

• But the instance variable’s scope (the class Rectangle) overlaps with the local variable’s scope (the method UpdateWidth)

• If two variables have the same name and overlapping scopes, the variable with the closer or smaller scope shadows the variable with the farther or wider scope: the name will refer only to the variable with the smaller scope

• In this case, that means width inside UpdateWidth refers only to the local variable named width, whose scope is smaller because it is limited to the UpdateWidth method. The line width = newWidth actually changes the local variable, not the instance variable named width.

• Since instance variables have a large scope (the whole class), they will always get shadowed by variables declared within methods

• You can prevent shadowing by using the keyword this, like this:

  class Rectangle
  {
      private int length;
      private int width;
      public void UpdateWidth(int newWidth)
      {
          int width = 5;
          this.width = newWidth;
      }
  }

  Since this means “the calling object”, this.width means “access the width member of the calling object.” This can only mean the instance variable width, not the local variable with the same name

• Incidentally, you can also use this to give your parameters the same name as the instance variables they are modifying:

  class Rectangle
  {
      private int length;
      private int width;
      public void SetWidth(int width)
      {
          this.width = width;
      }
  }

  Without this, the body of the SetWidth method would be width = width;, which does not do anything (it would assign the parameter width to itself).

A class we will use for subsequent examples

• ClassRoom: Represents a room in a building on campus

• UML Diagram:

  |=========================================|
  |                **ClassRoom**            |
  | --------------------------------------- |
  | - building: `string`                    |
  | - number: `int`                         |
  | --------------------------------------- |
  | + SetBuilding(buildingParam : `string`) |
  | + GetBuilding(): `string`               |
  | + SetNumber(numberParameter: `int`)     |
  | + GetNumber(): `int`                    |
  |=========================================|

  • There are two attributes: the name of the building (a string) and the room number (an int)
  • Each attribute will have a “getter” and “setter” method

• Implementation:

  class ClassRoom
  {
      private string building;
      private int number;
  
      public void SetBuilding(string buildingParam)
      {
          building = buildingParam;
      }
  
      public string GetBuilding()
      {
          return building;
      }
  
      public void SetNumber(int numberParam)
      {
          number = numberParam;
      }
  
      public int GetNumber()
      {
          return number;
      }
  }

  • Each attribute is implemented by an instance variable with the same name
  • To write the “setter” for the building attribute, we write a method whose return type is void, with a single string-type parameter. Its body assigns the building instance variable to the value in the parameter buildingParam
  • To write the “getter” for the building attribute, we write a method whose return type is string, and whose body returns the instance variable building

• Creating an object and using its default values:

  using System;
  
  class Program
  {
      static void Main(string[] args)
      {
          ClassRoom english = new ClassRoom();
          Console.WriteLine($"Building is {english.GetBuilding()}");
          Console.WriteLine($"Room number is {english.GetNumber()}");
      }
  }

  This will print the following output:

  Building is
  Room number is 0

  Remember that the default value of a string variable is null. When you use string interpolation on null, you get an empty string.

Writing a constructor

• Example for ClassRoom:

  public ClassRoom(string buildingParam, int numberParam)
  {
      building = buildingParam;
      number = numberParam;
  }

• To write a constructor, write a method whose name is exactly the same as the class name

• This method has no return type, not even void. It does not have a return statement either

• For ClassRoom, this means the constructor’s header starts with public ClassRoom

  • You can think of this method as “combining” the return type and name. The name of the method is ClassRoom, and its output is of type ClassRoom, since the return value of new ClassRoom() is always a ClassRoom object
  • You do not actually write a return statement, though, because new will always return the new object after calling the constructor

• A custom constructor usually has parameters that correspond to the instance variables: for ClassRoom, it has a string parameter named buildingParam, and an int parameter named numberParam

  • Note that when we write a method with two parameters, we separate the parameters with a comma

• The body of a constructor must assign values to all instance variables in the object

• Usually this means assigning each parameter to its corresponding instance variable: initialize the instance variable to equal the parameter

  • Very similar to calling both “setters” at once

• Using a constructor

• An instantiation statement will call a constructor for the class being instantiated

• Arguments in parentheses must match the parameters of the constructor

• Example with the ClassRoom constructor:

  using System;
  
  class Program
  {
      static void Main(string[] args)
      {
          ClassRoom csci = new ClassRoom("Allgood East", 356);
          Console.WriteLine($"Building is {csci.GetBuilding()}");
          Console.WriteLine($"Room number is {csci.GetNumber()}");
      }
  }

  This program will produce this output:

  Building is Allgood East
  Room number is 356

• The instantiation statement new ClassRoom("Allgood East", 356) first creates a new “empty” object of type ClassRoom, then calls the constructor to initialize it. The first argument, “Allgood East”, becomes the constructor’s first parameter (buildingParam), and the second argument, 356, becomes the constructor’s second parameter (numberParam).

• After executing the instantiation statement, the object referred to by csci has its instance variables set to these values, even though we never called SetBuilding or SetNumber

Methods with multiple parameters

• The constructor we wrote is an example of a method with two parameters

• The same syntax can be used for ordinary, non-constructor methods, if we need more than one input value

• For example, we could write this method in the Rectangle class:

  public void MultiplyBoth(int lengthFactor, int widthFactor)
  {
      length *= lengthFactor;
      width *= widthFactor;
  }

• The first parameter has type int and is named lengthFactor. The second parameter has type int and is named widthFactor

• You can call this method by providing two arguments, separated by a comma:

  Rectangle myRect = new Rectangle();
  myRect.SetLength(5);
  myRect.SetWidth(10);
  myRect.MultiplyBoth(3, 5);

  The first argument, 3, will be assigned to the first parameter, lengthFactor. The second argument, 5, will be assigned to the second parameter, widthFactor

• The order of the arguments matters when calling a multi-parameter method. If you write myRect.MultiplyBoth(5, 3), then lengthFactor will be 5 and widthFactor will be 3.

• The type of each argument must match the type of the corresponding parameter. For example, when you call the ClassRoom constructor we just wrote, the first argument must be a string and the second argument must be an int

Writing multiple constructors

• Remember that if you do not write a constructor, C# generates a “default” one with no parameters, so you can write new ClassRoom()

• Once you add a constructor to your class, C# will not generate a default constructor

  • This means once we write the ClassRoom constructor (as shown earlier), this statement will produce a compile error: ClassRoom english = new ClassRoom();
  • The constructor we wrote has 2 parameters, so now you always need 2 arguments to instantiate a ClassRoom

• If you still want the option to create an object with no arguments (i.e. new ClassRoom()), you must write a constructor with no parameters

• A class can have more than one constructor, so it would look like this:

  class ClassRoom
  {
      //...
      public ClassRoom(string buildingParam, int numberParam)
      {
          building = buildingParam;
          number = numberParam;
      }
      public ClassRoom()
      {
          building = null;
          number = 0;
      }
      //...
  }

• The “no-argument” constructor must still initialize all the instance variables, even though it has no parameters

  • You can pick any “default value” you want, or use the same ones that C# would use (0 for numeric variables, null for object variables, etc.)

• When a class has multiple constructors, the instantiation statement must decide which constructor to call

• The instantiation statement will call the constructor whose parameters match the arguments you provide

  • For example, each of these statements will call a different constructor:

    ClassRoom csci = new ClassRoom("Allgood East", 356);
    ClassRoom english = new ClassRoom();

    The first statement calls the two-parameter constructor we wrote, since it has a string argument and an int argument (in that order), and those match the parameters (string buildingParam, int numberParam). The second statement calls the zero-parameter constructor since it has no arguments.

  • If the arguments do not match any constructor, it is still an error:

    ClassRoom csci = new ClassRoom(356, "Allgood East");

    This will produce a compile error, because the instantiation statement has two arguments in the order int, string, but the only constructor with two parameters needs the first parameter to be a string.

Name uniqueness in C#

• In general, variables, methods, and classes must have unique names, but there are several exceptions
• Variables can have the same name if they are in different scopes
  • Two methods can each have a local variable with the same name
  • A local variable (scope limited to the method) can have the same name as an instance variable (scope includes the whole class), but this will result in shadowing
• Classes can have the same name if they are in different namespaces

  • This is one reason C# has namespaces: you can name your classes anything you want. Otherwise, if a library (someone else’s code) used a class name, you would be prevented from using that name

  • For example, imagine you were using a “shapes library” that provided a class named Rectangle, but you also wanted to write your own class named Rectangle

  • The library’s code would use its own namespace, like this:

    namespace ShapesLibrary
    {
        class Rectangle
        {
            //instance variables, methods, etc.
        }
    }

    Then your own code could have a Rectangle class in your own namespace:

    namespace MyProject
    {
        class Rectangle
        {
            //instance variables, methods, etc.
        }
    }

  • You can use both Rectangle classes in the same code, as long as you specify the namespace, like this:

    MyProject.Rectangle rect1 = new MyProject.Rectangle();
    ShapesLibrary.Rectangle rect2 = new ShapesLibrary.Rectangle();

• Methods can have the same name if they have different signatures; this is called overloading

  • We’ll explain signatures in more detail in a minute

  • Briefly, methods can have the same name if they have different parameters

  • For example, you can have two methods named Multiply in the Rectangle class, as long as one has one parameter and the other has two parameters:

    public void Multiply(int factor)
    {
        length *= factor;
        width *= factor;
    }
    public void Multiply(int lengthFactor, int widthFactor)
    {
        length *= lengthFactor;
        width *= widthFactor;
    }

    C# understands that these are different methods, even though they have the same name, because their parameters are different. If you write myRect.Multiply(2) it can only mean the first “Multiply” method, not the second one, because there is only one argument.

  • We have used overloading already when we wrote multiple constructors – constructors are methods too. For example, these two constructors have the same name, but different parameters:

    public ClassRoom(string buildingParam, int numberParam)
    {
        building = buildingParam;
        number = numberParam;
    }
    public ClassRoom()
    {
        building = null;
        number = 0;
    }

Method signatures

• A method’s signature has 3 components: its name, the type of each parameter, and the order the parameters appear in
• Methods are unique if their signatures are unique, which is why they can have the same name
• Signature examples:
  • public void Multiply(int lengthFactor, int widthFactor) – the signature is Multiply(int, int) (name is Multiply, parameters are int and int type)
  • public void Multiply(int factor) – signature is Multiply(int)
  • public void Multiply(double factor) – signature is Multiply(double)
  • These could all be in the same class since they all have different signatures
• Parameter names are not part of the signature, just their types

  • Note that the parameter names are omitted when I write down the signature

  • That means these two methods are not unique and could not be in the same class:

    public void SetWidth(int widthInMeters)
    {
        //...
    }
    public void SetWidth(int widthInFeet)
    {
        //...
    }

    Both have the same signature, SetWidth(int), even though the parameters have different names. You might intend the parameters to be different (i.e. represent feet vs. meters), but any int-type parameter is the same to C#

• The method’s return type is not part of the signature
  • So far all the examples have the same return type (void), but changing it would not change the signature
  • The signature of public int Multiply(int factor) is Multiply(int), which is the same as public void Multiply(int factor)
  • The signature “begins” with the name of the method; everything “before” that does not count (i.e. public, int)
• The order of parameters is part of the signature, as long as the types are different

  • Since parameter name is not part of the signature, only the type can determine the order

  • These two methods have different signatures:

    public int Update(int number, string name)
    {
        //...
    }
    public int Update(string name, int number)
    {
        //..
    }

    The signature of the first method is Update(int, string). The signature of the second method is Update(string, int).

  • These two methods have the same signature, and could not be in the same class:

    public void Multiply(int lengthFactor, int widthFactor)
    {
        //...
    }
    public void Multiply(int widthFactor, int lengthFactor)
    {
        //...
    }

    The signature for both methods is Multiply(int, int), even though we switched the order of the parameters – the name does not count, and they are both int type

• Constructors have signatures too
  • The constructor ClassRoom(string buildingParam, int numberParam) has the signature ClassRoom(string, int)
  • The constructor ClassRoom() has the signature ClassRoom()
  • Constructors all have the same name, but they are unique if their signatures (parameters) are different