1. C# Control Statements part 1 (Based on Deitel Book)

2. Reading User Input
For example

3. Code using System; using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Decisions {
class Program
static void Main(string[] args)
Console.WriteLine("Please enter something and press Enter");
string userInputValue;
userInputValue = Console.ReadLine(); //Reading User input
Console.WriteLine("You entered {0}", userInputValue);
Console.ReadLine(); //WAITING }

4. If, else if, if static void Main(string[] args) {
Console.WriteLine("Please 1 or 2");
string userInputValue;
userInputValue = Console.ReadLine(); //READING USER INPUT
if (userInputValue == "1")
Console.WriteLine("You entered ONE"); }
else if (userInputValue == "2")
Console.WriteLine("You entered TWO");
else
Console.WriteLine("You entered SOMETHING ELSE {1} “, userInputValue );
Console.ReadLine(); //WAITING

5. Refactoring using message
static void Main(string[] args) {
Console.WriteLine("Please 1 or 2");
string userInputValue = Console.ReadLine(); //READING USER INPUT in one line
string message;
if (userInputValue == "1")
message = "You entered ONE"; }
else if (userInputValue == "2")
message = "You entered TWO";
else
message = "You entered SOMETHING ELSE";
Console.WriteLine(message);
Console.ReadLine(); //WAITING
No {}
Only if it is 1 line of code, but not recommended.
USE { }

6. 5.5 if Single-Selection Statement

7. 5.6 if…else Double-Selection Statement

8. if(x>0);

9. == vs = == (test equality) - results true or false if(x == 0) {
//do something }
= (assignment)
X = 0;

10. if else General if(condition1) {
One line does no need {} but use them anyway }
else if(condition2)
else

11. Statement: operators and operands

12. String.Format DateTime dt = new DateTime(2016, 1, 17, 9, 30, 0);
System.DateTime
DateTime dt = new DateTime(2016, 1, 17, 9, 30, 0);
string city = "Chicago";
int temp = -16;
string output =
String.Format("At {0} in {1},the temperature was {2} degrees.", dt, city, temp);
Console.WriteLine(output);
// The example displays the following output:
// At 1/17/2016 9:30:00 AM in Chicago, the temperature was -16 degrees.

13. C# Primitives (again) C# Primitives Type Primitive Usage Range bool
System.Boolean
boolean
true, false
byte
System.Byte
8 bit integer
char
System.Char
16 bit Unicode character
/u0000 - /uffff
decimal
System.Decimal
128 bit decimal
+/-1.0x10-28 to +/-7.9x10+28 precision of digits
double
System.Double
64 bit floating point
e308 to e308
float
System.Single
32 bit floating point
+/-1.5x10-45 to +/-3.4x10+38 precision of 7 digits
int
System.Int32
32 bit integer
-2,147,483,648 to 2,147,483,647
long
System.Int64
64 bit integer
-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
sbyte
System.SByte
-128 to 127
short
System.Int16
16 bit integer
-32,768 to 32,767
string
System.String -
immutable, specified length
uint
System.UInt32
32 bit unsigned integer
0 to 4,294,967,295
ulong
System.UInt64
64 bit unsigned integer
0 to 18,446,744,073,709,551,615
ushort
System.UInt16
16 bit unsigned integer
0 to 65,535

14. operators
shortcut

15. Comparison operators (return true or false)
Greater
Less
Greater OR equal
Less OR equal

16. Logical Operators

17. Increment/Decrement operators
Prefix and Postfix Operators

18. Type testing (more later)

19. Ternary operator ?:
Another way

20. Ternary operator example w/ user input (Decisions)
string message =
(userInputValue == “1”)? “You entered ONE”:”You entered SOMETHING ELSE”;

21. Operator Precedence
means AND
means OR

22. Constants

23. Enumerations* (more later)
By default int type, can be changed

24. Loops
Executes at least once
later

25. 5.7 while Repetition Statement

26. 5.8 Formulating Algorithms: Counter-Controlled Repetition (remember?)

27. Auto-Implemented Properties
In C# 3.0 and later, auto-implemented properties make property-declaration more concise when no additional logic is required in the property accessors.
They also enable client code to create objects. When you declare a property, the compiler creates a private, anonymous backing field that can only be accessed through the property
No need for getX and setX like it is in Java

28. // This class is mutable
// This class is mutable. Its data can be modified from outside the class.
class Customer {
// Auto-Implementated Properties for trivial get and set
public double TotalPurchases { get; set; }
public string Name { get; set; }
public int CustomerID { get; set; }
// Constructor
public Customer(double purchases, string name, int ID) {
TotalPurchases = purchases;
Name = name;
CustomerID = ID; }
// Methods
public string GetContactInfo() {return "ContactInfo";}
public string GetTransactionHistory() {return "History";}
// .. Additional methods, events, etc.
class Program
static void Main()
{// Intialize a new object.
Customer cust1 = new Customer( , "Northwind", 90108);
Console.WriteLine("TORAL PURCHASES AFTER INIT {0} ",cust1.TotalPurchases);
cust1.TotalPurchases += ; //Modify a property
Console.WriteLine("TORAL PURCHASES UPDATED {0} ", cust1.TotalPurchases);
Console.ReadKey();

30. Local variables

34. class Rounding {
static void Main()
int x = 7;
int y = 4;
Console.WriteLine("x/y = {0} ", x / y); //1
Console.ReadKey(); }

35. Sentinel value
In computer programming, a sentinel value 
(also referred to as a flag value, trip value, rogue value, signal value, or dummy data) is a special value in the context of an algorithm which uses its presence as a condition of termination, typically in a loop or recursive algorithm.

36. 5.9 Formulating Algorithms: Sentinel-Controlled Repetition
Three phases:

40. Avoid infinite loop! Avoid division by 0
// determine the average of an arbitrary number of grades
public void DetermineClassAverage() {
int total; // sum of grades
int gradeCounter; // number of grades entered
int grade; // grade value
double average; // number with decimal point for average
// initialization phase
total = 0; // initialize total
gradeCounter = 0; // initialize loop counter
// processing phase
// prompt for and read a grade from the user
Console.Write( "Enter grade or -1 to quit: " );
grade = Convert.ToInt32( Console.ReadLine() );
// loop until sentinel value is read from the user
while ( grade != -1 ) {
total = total + grade; // add grade to total
gradeCounter = gradeCounter + 1; // increment counter
// prompt for and read the next grade from the user
} // end while
// termination phase
// if the user entered at least one grade...
if ( gradeCounter != 0 )
// calculate the average of all the grades entered
average = ( double ) total / gradeCounter;
// display the total and average (with two digits of precision)
Console.WriteLine( "\nTotal of the {0} grades entered is {1}",
gradeCounter, total );
Console.WriteLine( "Class average is {0:F}", average );
} // end if
else // no grades were entered, so output error message
Console.WriteLine( "No grades were entered" );
} // end method DetermineClassAverage }
Avoid infinite loop!
Avoid division by 0

42. 5.9 Explicitly and Implicitly Converting Between Simple Types
To perform a floating-point calculation with integer values, we temporarily treat these values as floating-point numbers.
A unary cast operator such as (double) performs explicit conversion.
C# performs an operation called promotion (or implicit conversion) on selected operands for use in the expression.

43. 55.9 Explicitly and Implicitly Converting Between Simple Types (cont.)
The cast operator is formed by placing parentheses around the name of a type. This operator is a unary operator (i.e., an operator that takes only one operand).
Cast operators associate from right to left and have the same precedence as other unary operators, such as unary + and unary -. This precedence is one level higher than that of the multiplicative operators *, / and %.

44. 5.9 Explicitly and Implicitly Converting Between Simple Types (cont.)
In GradeBook app, the three grades entered during the sample execution of class GradeBookTest (Fig. 5.10) total 263, which yields the average ….
The format item rounds the average to the hundredths position, and the average is displayed as
Console.WriteLine( "\nTotal of the {0} grades entered is {1}",
gradeCounter, total );
Console.WriteLine( "Class average is {0:F}", average );

45. Standard Numeric Format Strings
("F", en-US) ->
("F", de-DE) -> 1234,57
1234 ("F1", en-US) ->
1234 ("F1", de-DE) -> 1234,0
("F4", en-US) ->
("F4", de-DE) -> -1234,5600
("C", en-US) -> $123.46
("C", fr-FR) -> 123,46 €
("C", ja-JP) -> ¥123
("C3", en-US) -> ($ )
("C3", fr-FR) -> -123,456 €
("C3", ja-JP) -> -¥
1234 ("D") -> 1234
-1234 ("D6") ->

47. 5.10 Formulating Algorithms: Nested Control Statements

51. Notes Type Conversion
C# statically types at compile time. After variable declaration the type is set
Conversion:
Implicit (when it is safe)
From smaller to larger (int to double)
From derived to base class
Explicit (cast)
Variables compatible, but risk of precision loss (smaller to larger)
Using helpers (between non-compatible types)
System.BitConverter
System.Convert

52. Notes Type Conversion Int32.Parse
The Convert.ToInt32(String, IFormatProvider) underneath calls the Int32.Parse. So the only difference is that if a null string is passed to Convert it returns 0, whereas Int32.Parse throws an ArgumentNullException. 
MSDN

54. 5.11 Compound Assignment Operators

55. 5.12 Increment and Decrement Operators

56. // Fig. 5.16: Increment.cs
// Prefix increment and postfix increment operators.
using System;
public class Increment {
public static void Main( string[] args )
int c;
// demonstrate postfix increment operator
c = 5; // assign 5 to c
Console.WriteLine( c ); // display 5
Console.WriteLine( c++ ); // display 5 again, then increment
Console.WriteLine( c ); // display 6
Console.WriteLine(); // skip a line
// demonstrate prefix increment operator
Console.WriteLine( ++c ); // increment then display 6
Console.WriteLine( c ); // display 6 again
} // end Main }

59. 5.13 Simple Types (and again)
The table in Appendix B, Simple Types, lists the 13 simple types in C#.
C# requires all variables to have a type.
Instance variables of types char, byte, sbyte, short, ushort, int, uint, long, ulong, float, double, and decimal are all given the value 0 by default.
Instance variables of type bool are given the value false by default.