[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/1.%20C%23%20Basics%20Assignments)
More types listed in the [C# reference](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/built-in-types)!
double airPressure = 1.2; // Use generally for everything
### Data type examples
```csharp
double airPressure = 1.2; // Use for most decimal numbers
decimal accountBalance = 1.2m; // Use for accuracy (e.g. financial applications)
float bulletSpeed = 1.2f; // Use only when you know the precision will be enough (in other words, don't use)
float bulletSpeed = 1.2f; // Use only when you know its precision will be enough
bool loggedIn = false;
char previousInput = 'b';
```
# Assignments (variables)
* `char` is only used for single characters, multi-character ***strings*** will be introduced in a bit.
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.1.%20Variables%20&%20Types)
## Extra: Casting data types
<!-- _class: "extra invert" -->
# Assignments (data types)
Data types can be ***cast*** to another either...
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.2.%20Data%20Types)
# What are arithmetic operations?
The arithmetic operations are common mathematical operations:
* Casting is useful when, for example, when we want to sum a `double` and a `decimal` together:
```csharp
double a = 1.0;
decimal b = 2.1m;
Console.WriteLine(a + (double)b);
Console.WriteLine((decimal)a + b);
```
* [C# Guide: Casting and type conversions](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/types/casting-and-type-conversions)
Earlier we used an _arithmetic operator _ to subtract b from a:
## Assignments (variables)
<!--_class: "exercise invert" -->
Console.WriteLine(a - b);
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.1.%20Variables%20&%20Types)
# Arithmetic Operators
## Assignments (data types)
<!--_class: "exercise invert" -->
| Operator | Name | Example | Description |
| :-: | :-: | :-: | :-: |
| + | Addition | a + b | Adds together two values |
| - | Subtraction | a - b | Subtracts one value from another |
| * | Multiplication | a * b | Multiplies two values |
| / | Division | a / b | Divides one value by another |
| % | Modulus | a % b | Returns the division remainder |
| ++ | Increment | a++ | Increases the value of a variable by 1 |
| -- | Decrement | a–- | Decreases the value of a variable by 1 |
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.2.%20Data%20Types)
---
## Arithmetic operations?
Tässä on kaikki aritmeettiset operaattorit
* ***Arithmetic operations*** are common mathematical operations:
* Addition
* Subtraction
* Multiplication
* Division
* Modulus (remainder, in Finnish *jakojäännös*)
* The operations are represented by **_arithmetic operators_**
# Exercise 1: Trying Out Variables
## Arithmetic Operators
Create a new console application as we did in the last exercise and declare two variables of type __double__ _._
| `++` | Increment | `a++` | Increases the value by 1 |
| `--` | Decrement | `a–-` | Decreases the value by 1 |
## Exercise 1: Trying Out Variables
<!--_class: "exercise invert" -->
1) Create a new console application and declare two variables of type `double`.
2) Assign different values for those variables.
3) Print the sum, difference, fraction and product of those values to the console.
## The assignment operator
We have used the assignment operator `=` for assigning values for variables:
```csharp
int x;
x = 25;
```
* ***Note*** the difference between `=` and `==` introduced in [Lecture 3](3-conditionals#comparison-operators)!
* `=` is used for assigning values for variables, `==` is used for ***comparing*** values
Assign different values for those variables.
### Assignment operators
Print the __sum__ , __difference__ , __fraction __ and __product __ of those values to the console.
<divclass='columns'markdown='1'>
<divmarkdown='1'>
# Increment & Decrement
| Operator | Example | Same As |
|:---------|:---------|:------------|
| `=` | `x = 5` | `x = 5` |
| `+=` | `x += 5` | `x = x + 5` |
| `-=` | `x -= 5` | `x = x - 5` |
| `*=` | `x *= 5` | `x = x * 5` |
| `/=` | `x /= 5` | `x = x / 5` |
| `%=` | `x %= 5` | `x = x % 5` |
Increment and decrement operations are operations that can be used to increment or decrement a variable value by 1.
</div>
<divmarkdown='1'>
Most programming languages implement these operations
* As shown here, there are some assignment operators that work as ***shorthands*** for longer assignments
* Particularly useful when the variable name is longer, so you don't have to write it twice when its value is changed
Addition example: int a = 3; a = a + 1; _// a is now 4_ Can be written with increment: int a = 3; a++; _// a is now 4_
</div>
</div>
Decrement is like increment but with just subtraction
Substraction example: int a = 3; a = a - 1; _// a is now 2_ Can be written with decrement: int a = 3; a--; _// a is now 2_
### Assignment operators: An example
Increment and decrement operators can be written in two ways. So sometimes you may also see this: int a = 3; --a; _// a is now 2__ _ ++a; _// a is now 3_
```csharp
int uppercaseLetters = 2;
uppercaseLetters += 4; // is now 6
This will do the same thing as a++ and a--. There is a small difference between these syntaxes though.
int specialCharacters = 2;
specialCharacters *= 2; // is now 4
int a = 3;const _ _ b = _ _ a++; _// b will be 3_ Console.WriteLine(a); _// this will print out 4_ Here the assignment to b happens before incrementing a, thus b will be assigned value 3.
Console.WriteLine(uppercaseLetters);
Console.WriteLine(specialCharacters);
```
int a = 3;const _ _ b = _ _ ++a; _// b will be 4_ Console.WriteLine(a); _// this will print out 4_ Here the assignment to b happens after incrementing a, thus b will be assigned value 4.
### Increment and decrement operations
---
* You can increment or decrement a variable value by 1 with dedicated short-hands
* Most programming languages implement these!
Täällä voi helposti demota: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Increment
<divclass='columns'markdown='1'>
<divmarkdown='1'>
# Assignment Operators
* Addition example:
```csharp
int a = 3;
We have used the assignment operator ' __='__ for assigning values for variables:
a = a + 1; // a is now 4
a += 1; // a is now 5
a++; // a is now 6
```
int x;
</div>
<divmarkdown='1'>
x = 25;
* Subtraction example:
```csharp
int a = 3;
__Notice __ the difference between '=' and the conditional '=='!
a = a - 1; // a is now 2
a -= 1; // a is now 1
a--; // a is now 0
```
'=' is used for assigning values for variables, '== is used for comparing values
| Operator | Example | Same As |
| :-: | :-: | :-: |
| = | x = 5 | x = 5 |
| += | x += 5 | x = x + 5 |
| -= | x -= 5 | x = x - 5 |
| *= | x *= 5 | x = x * 5 |
| /= | x /= 5 | x = x / 5 |
| %= | x %= 5 | x = x % 5 |
</div>
</div>
---
* `++` and `--` are called the ***increment and decrement operators***
Tässä on joitakin asetusoperaattoreita, lisäksi loogiset (ei käydä tässä)
* Note that incrementing can be written as ***prefix*** (`++i`) or a ***postfix*** (`i++`)
* In this example, `a++` and `++a` do exactly the same:
```csharp
int a = 3;
a++; // a is now 4
++a; // a is now 5
```
* Their exact difference is [complicated](https://stackoverflow.com/questions/3346450/what-is-the-difference-between-i-and-i-in-c), and in some cases, using either prefix or postfix form can produce different results:
uppercaseLetters += 4; // is now 6
<divclass='columns'markdown='1'>
<divmarkdown='1'>
int specialCharacters = 2;
```csharp
int a = 3;
int b = ++a;
Console.WriteLine(b); // 4
```
Assignment of `b` happens after `++`,
so its value is 4
specialCharacters *= 2; // is now 4
</div>
<divmarkdown='1'>
Console.WriteLine(uppercaseLetters);
```csharp
int a = 3;
int b = a++;
Console.WriteLine(b); // 3
```
Assignment of `b` happens before `++`,
so its value is 3
Console.WriteLine(specialCharacters);
</div>
</div>
This outputs 6 and 4
# Strings
## Strings
String is a special type, which contains an array of characters. You can declare and assign strings like any other type of variables:
You can add __format strings__ to change the way variables are interpolated into a string
@ -304,7 +396,7 @@ Console.WriteLine($"Pi to three digits: {pi:G3}");
// Outputs "Pi to three digits: 3.14"
# Console.ReadLine()
## Console.ReadLine()
For the next exercise, you'll need the Console.ReadLine() method. The method pauses the program, waits for an input stream from the console that pops up, and returns the value of the input:
Create a console application which asks the user which weekday it is and assigns the answer to a string variable.
Print "Have a nice weekday!" to the console where weekday is replaced with the string the user wrote.
# Assignments (arithmetic operations)
## Assignments (arithmetic operations)
<!--_class: "exercise invert" -->
[Assignments about this topic can be found here](https://gitea.buutti.com/education/academy-assignments/src/branch/master/C%23%20Basics/2.3.%20Arithmetic%20Operations)
borb
1 week ago