From 3fbcc8d9e5ed6b7e17801ebce66251fa3f752d94 Mon Sep 17 00:00:00 2001 From: ipvg Date: Mon, 29 Jul 2024 01:49:26 -0400 Subject: [PATCH] avnc 021 --- .../021_csharp.md | 495 ++++++++++++++++++ .../test_app/Program.cs | 65 +++ .../test_app/test_app.csproj | 10 + README.md | 41 +- 4 files changed, 591 insertions(+), 20 deletions(-) create mode 100644 021_Casting_and_conversion_techniques/021_csharp.md create mode 100644 021_Casting_and_conversion_techniques/test_app/Program.cs create mode 100644 021_Casting_and_conversion_techniques/test_app/test_app.csproj diff --git a/021_Casting_and_conversion_techniques/021_csharp.md b/021_Casting_and_conversion_techniques/021_csharp.md new file mode 100644 index 0000000..30fc68d --- /dev/null +++ b/021_Casting_and_conversion_techniques/021_csharp.md @@ -0,0 +1,495 @@ +# Convert data types using casting and conversion techniques + +Take control of the data in your applications, knowing when to apply the +correct technique to change data types as needed. + +### Learning objectives + +Use the casting operator to cast a value into a different data type. + +Use conversion methods to convert a value into a different data type. + +Guard against the loss of data when performing a cast or conversion operation. + +Use the `TryParse()` method to safely convert a string into a numeric data type. + +## Introduction + +Suppose you're a software developer on a team working on medical intake form +automation. You're tasked with delivery of the application features for +collecting data entered by a medical technician before the doctor sees the +patient. The technician can use the application to record the date and time, +patient age, height, weight, pulse, and blood pressure. The application also +provides text fields for other information, such as the reason for the visit, +current prescriptions, and other items. You work with many data that is in a +mix of data types. For the prototype, you'll build a console application and +collect all of the input as `strings`. + +Because the input is initially input as a string, you need to occasionally +change values from one data type into another in the code. A simple example is +any mathematical operation you want to perform with string data. You would +first need to change the value into a numeric data type, like `int`, and then you +could manipulate the operation. Alternatively, you may want to format and +output a numeric value for a summary report using string interpolation. + +You use different techniques to change a data type when necessary. You learn +when to use one technique over another, and when a given technique might risk +the loss of data. + +By the end of this module, you're able to take control of the data in your +applications, knowing when to apply the correct technique to change data types +as needed. + +### Learning objectives + +In this module, you'll: + +- Use the casting operator to cast a value into a different data type. +- Use conversion methods to convert a value into a different data type. +- Guard against the loss of data when performing a cast or conversion operation. +- Use the `TryParse()` method to safely convert a string into a numeric data +type. + +--- + +## Exercise + +### Explore data type casting and conversion + +There are multiple techniques to perform a data type conversion. The technique +you choose depends on your answer to two important questions: + +- Is it possible, depending on the value, that attempting to change the value's data type would throw an exception at run time? +- Is it possible, depending on the value, that attempting to change the value's data type would result in a loss of information? +In this exercise, you work your way through these questions, the implications of their answers, and which technique you should use when you need to change the data type. + +#### Prepare your coding environment + +Create a new console application. At the Terminal command prompt type: +`dotnet new console -o ./path_to/Project` or `dotnet new console -n "Project"` +and then press Enter. + +This .NET CLI command uses a .NET program template to create a new C# console +application project in the specified folder location. + +You use this C# console project to create, build, and run code samples during +this module. + +Close the Terminal panel. + +### Question + +**Is it possible that attempting to change the value's data type would throw an +exception at run time?** + +The C# compiler attempts to accommodate your code, but doesn't compile +operations that could result in an exception. When you understand the C# +compiler's primary concern, understanding why it functions a certain way is +easier. + +#### Write code that attempts to add an `int` and a `string` and save the result in an `int` + +Type the following code into the Visual Studio Code Editor: + +```cs +int first = 2; +string second = "4"; +int result = first + second; +Console.WriteLine(result); +``` + +Here, you're attempting to add the values `2` and `4`. The value `4` is of type +`string`. Will this work? + +At the Terminal command prompt, to run your code, type `dotnet run` and then +press Enter. + +You should see the following approximate output + +Windows: + +```txt +C:\Users\someuser\Documents\csharpprojects\TestProject\Program.cs(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int' +``` + +Linux: + +```txt +/home/user/Projects/TestProject/Program.cs(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int' +``` + +> Note +> If you see a message saying "Couldn't find a project to run", ensure that the +Terminal command prompt displays the expected TestProject folder location. For +example: `C:\Users\someuser\Documents\csharpprojects\TestProject>` + +Take a minute to consider why the compiler was unable to run the first code sample. + +The important part of the error message, +`(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'`, tells +you the problem is with the use of the string data type. + +But why can't the C# Compiler just handle the error? After all, you can do the +opposite to concatenate a number to a `string` and save it in a string variable. +Here, you change the data type of the `result` variable from `int` to string. + +Update your code in the editor as follows: + +```cs +int first = 2; +string second = "4"; +string result = first + second; +Console.WriteLine(result); +``` + +Save your code file, and then run your code. + +You should observe the following output: + +```txt +24 +``` + +The output is mathematically incorrect but completes by combining the values as +the characters "2" and "4". + +Examine, once again, the first code example where the `result` variable is of +type `int`. The code with the error message. + +```cs +int first = 2; +string second = "4"; +int result = first + second; +Console.WriteLine(result); +``` + +Why can't the C# compiler figure out that you want to treat the variable `second` +containing `4` as a number, not a `string`? + +### Compilers make safe conversions + +The C# compiler sees a potential problem in the making. The variable `second` is +of type `string`, so it might be set to a different value like `"hello"`. If the +C# compiler attempted to convert "hello" to a number that would cause an +exception at runtime. To avoid this possibility, the C# compiler doesn't +implicitly perform the conversion from `string` to `int` for you. + +From the C# compiler's perspective, the safer operation would be to convert +`int` into a `string` and perform concatenation instead. + +If you intend to perform addition using a string, the C# compiler requires you +to take more explicit control of the process of data conversion. In other words, +it forces you to be more involved so that you can put the proper precautions in +place to handle the possibility that the conversion could throw an exception. + +If you need to change a value from the original data type to a new data type +and the change could produce an exception at run time, you must perform a data +conversion. + +To perform data conversion, you can use one of several techniques: + +- Use a helper method on the data type +- Use a helper method on the variable +- Use the Convert class' methods + +You look at a few examples of these techniques for data conversion later in +this unit. + +### Question + +**Is it possible that attempting to change the value's data type would result in +a loss of information?** + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +int myInt = 3; +Console.WriteLine($"int: {myInt}"); + +decimal myDecimal = myInt; +Console.WriteLine($"decimal: {myDecimal}"); +``` + +Save your code file, and then run your code. + +You should see the following output: + +```txt +int: 3 +decimal: 3 +``` + +The key to this example is this line of code: + +```cs +decimal myDecimal = myInt; +``` + +Since any `int` value can easily fit inside of a `decimal`, the compiler performs +the conversion. + +The term *widening* conversion means that you're attempting to convert a value +**from** a data type that could hold less information **to** a data type that +can hold *more* information. In this case, a value stored in a variable of type +`int` converted to a variable of type `decimal`, doesn't lose information. + +When you know you're performing a widening conversion, you can rely on implicit +conversion. The compiler handles implicit conversions. + +### Perform a cast + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +decimal myDecimal = 3.14m; +Console.WriteLine($"decimal: {myDecimal}"); + +int myInt = (int)myDecimal; +Console.WriteLine($"int: {myInt}"); +``` + +To perform a cast, you use the casting operator `()` to surround a data type, +then place it next to the variable you want to convert (example: +`(int)myDecimal`). You perform an explicit conversion to the defined cast data +type (`int`). + +Save your file, and then run your code. + +You should see the following output: + +```txt +decimal: 3.14 +int: 3 +``` + +The key to this example is this line of code: + +```cs +int myInt = (int)myDecimal; +``` + +The variable `myDecimal` holds a value that has precision after the decimal poin +t. By adding the casting instruction `(int)`, you're telling the C# compiler that +you understand it's possible you'll lose that precision, and in this situation, +it's fine. You're telling the compiler that you're performing an intentional +conversion, an explicit conversion. + +### Determine if your conversion is a "widening conversion" or a "narrowing conversion" + +The term narrowing conversion means that you're attempting to convert a value +from a data type that can hold more information to a data type that can hold +less information. In this case, you may lose information such as precision +(that is, the number of values after the decimal point). An example is +converting value stored in a variable of type `decimal` into a variable of type +`int`. If you print the two values, you would possibly notice the loss of +information. + +When you know you're performing a narrowing conversion, you need to perform a +cast. Casting is an instruction to the C# compiler that you know precision may +be lost, but you're willing to accept it. + +If you're unsure whether you lose data in the conversion, write code to perform +a conversion in two different ways and observe the changes. Developers +frequently write small tests to better understand the behaviors, as illustrated +with the next sample. + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +decimal myDecimal = 1.23456789m; +float myFloat = (float)myDecimal; + +Console.WriteLine($"Decimal: {myDecimal}"); +Console.WriteLine($"Float : {myFloat}"); +``` + +Save your file, and then run your code. + +You should see output similar to: + +```txt +Decimal: 1.23456789 +Float : 1.2345679 +``` + +You can observe from the output that casting a `decimal` into a `float` is a +narrowing conversion because you're losing precision. + +### Performing Data Conversions + +Earlier, it was stated that a value change from one data type into another +could cause a runtime exception, and you should perform data conversion. For +data conversions, there are three techniques you can use: + +- Use a helper method on the variable +- Use a helper method on the data type +- Use the `Convert` class' methods + +### Use `ToString()` to convert a number to a `string` + +Every data type variable has a `ToString()` method. What the `ToString()` method +does depends on how it's implemented on a given type. However, on most +primitives, it performs a widening conversion. While this isn't strictly +necessary (since you can rely on implicit conversion in most cases) it can +communicate to other developers that you understand what you're doing and it's +intentional. + +Here's a quick example of using the `ToString()` method to explicitly convert +`int` values into strings. + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +int first = 5; +int second = 7; +string message = first.ToString() + second.ToString(); +Console.WriteLine(message); +``` + +Save your file, and then run the code, the output should display a +concatenation of the two values: + +```txt +57 +``` + +### Convert a `string` to an `int` using the `Parse()` helper method + +Most of the numeric data types have a `Parse()` method, which converts a +`string` into the given data type. In this case, you use the `Parse()` method +to convert two strings into int values, then add them together. + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +string first = "5"; +string second = "7"; +int sum = int.Parse(first) + int.Parse(second); +Console.WriteLine(sum); +``` + +Save your file, and then run the code, the output should display a sum of the +two values: + +```txt +12 +``` + +Take a minute to try to spot the potential problem with the previous code +example. What if either of the variables `first` or `second` are set to values +that can't be converted to an `int`? An exception is thrown at runtime. The C# +compiler and runtime expects you to plan ahead and prevent "illegal" +conversions. You can mitigate the runtime exception in several ways. + +The easiest way to mitigate this situation is by using `TryParse()`, which is a +better version of the `Parse()` method. + +### Convert a `string` to a `int` using the `Convert` class + +The `Convert` class has many helper methods to convert a value from one type +into another. In the following code example, you convert a couple of strings +into values of type `int`. + +> Note +> The code samples in this exercise are designed based on en-US culture setting +s, and use a period (`.`) as the decimal separator. Building and running the +code with a culture setting that uses a different decimal separators (such as a +comma `,`) may give unexpected results or errors. To fix this issue, replace +the period decimal separators in the code samples with your local decimal +separator (such as `,`). Alternatively, to run a program using the en-US +culture setting, add the following code to the top of your program: +`using System.Globalization;` and after any other `using` statements add +`CultureInfo.CurrentCulture = new CultureInfo("en-US");`. + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +string value1 = "5"; +string value2 = "7"; +int result = Convert.ToInt32(value1) * Convert.ToInt32(value2); +Console.WriteLine(result); +``` + +Save your file, and then run your code. + +You should see the following output: + +```txt +35 +``` + +> Note +> Why is the method name `ToInt32()`? Why not `ToInt()`? +> `System.Int32` is the name of the underlying data type in the .NET Class +Library that the C# programming language maps to the keyword `int`. Because the +`Convert` class is also part of the .NET Class Library, it is called by its +full name, not its C# name. By defining data types as part of the .NET Class +Library, multiple .NET languages like Visual Basic, F#, IronPython, and others +can share the same data types and the same classes in the .NET Class Library. + +The `ToInt32()` method has 19 overloaded versions allowing it to accept +virtually every data type. + +you used the `Convert.ToInt32()` method with a string here, but you should +probably use `TryParse()` when possible. + +So, when should you use the `Convert` class? The `Convert` class is best for +converting fractional numbers into whole numbers (`int`) because it rounds up +the way you would expect. + +### Compare casting and converting a `decimal` into an `int` + +The following example demonstrates what happens when you attempt to cast a +`decimal` into an `int` (a narrowing conversion) versus using the +`Convert.ToInt32()` method to convert the same `decimal` into an `int`. + +Delete or use the line comment operator `//` to comment out the code from the +previous exercise step, and add the following code: + +```cs +int value = (int)1.5m; // casting truncates +Console.WriteLine(value); + +int value2 = Convert.ToInt32(1.5m); // converting rounds up +Console.WriteLine(value2); +``` + +Save your file, and then run your code. + +You should see the following output: + +```txt +1 +2 +``` + +#### Casting truncates and converting rounds + +When you're casting `int value = (int)1.5m;`, the value of the float is truncated +so the result is `1`, meaning the value after the decimal is ignored completely. +You could change the literal float to `1.999m` and the result of casting would +be the same. + +When you're converting using `Convert.ToInt32()`, the literal float value is +properly rounded up to `2`. If you changed the literal value to `1.499m`, it +would be rounded down to `1`. + +### Recap + +You covered several important concepts of data conversion and casting: + +- Prevent a runtime error while performing a data conversion +- Perform an explicit cast to tell the compiler you understand the risk of +losing data +- Rely on the compiler to perform an implicit cast when performing an expanding +conversion +- Use the `()` cast operator and the data type to perform a cast (for example, +`(int)myDecimal`) +- Use the `Convert` class when you want to perform a narrowing conversion, but +want to perform rounding, not a truncation of information diff --git a/021_Casting_and_conversion_techniques/test_app/Program.cs b/021_Casting_and_conversion_techniques/test_app/Program.cs new file mode 100644 index 0000000..9d6bcc0 --- /dev/null +++ b/021_Casting_and_conversion_techniques/test_app/Program.cs @@ -0,0 +1,65 @@ +// int first = 2; +// string second = "4"; +// int result = first + second; +// Console.WriteLine(result); +string sep = "----------------------------------"; + +int first = 2; +string second = "4"; +string result = first + second; +Console.WriteLine(result); + +Console.WriteLine(sep); + +int myInt = 3; +Console.WriteLine($"int: {myInt}"); + +decimal myDecimal = myInt; +Console.WriteLine($"decimal: {myDecimal}"); + +Console.WriteLine(sep); + +myDecimal = 3.14m; +Console.WriteLine($"decimal: {myDecimal}"); + +myInt = (int)myDecimal; +Console.WriteLine($"int: {myInt}"); + +Console.WriteLine(sep); + +myDecimal = 1.23456789m; +float myFloat = (float)myDecimal; + +Console.WriteLine($"Decimal: {myDecimal}"); +Console.WriteLine($"Float : {myFloat}"); + +Console.WriteLine(sep); + +// first = 5; +// second = 7; +// string message = first.ToString() + second.ToString(); +// Console.WriteLine(message); + +Console.WriteLine(sep); + +string first_str = "5"; +second = "7"; +int sum = int.Parse(first_str) + int.Parse(second); +Console.WriteLine(sum); + +Console.WriteLine(sep); + +string value1 = "5"; +string value2 = "7"; +int result_1 = Convert.ToInt32(value1) * Convert.ToInt32(value2); +Console.WriteLine(result_1); + +Console.WriteLine(sep); + +int value_1 = (int)1.5m; // casting truncates +Console.WriteLine(value_1); + +int value_2 = Convert.ToInt32(1.5m); // converting rounds up +Console.WriteLine(value_2); + +Console.WriteLine(sep); diff --git a/021_Casting_and_conversion_techniques/test_app/test_app.csproj b/021_Casting_and_conversion_techniques/test_app/test_app.csproj new file mode 100644 index 0000000..2150e37 --- /dev/null +++ b/021_Casting_and_conversion_techniques/test_app/test_app.csproj @@ -0,0 +1,10 @@ + + + + Exe + net8.0 + enable + enable + + + diff --git a/README.md b/README.md index dd62589..baa72f8 100644 --- a/README.md +++ b/README.md @@ -5,23 +5,24 @@ Following ## Foundational C# with Microsoft -- [First Code](./001_first_code/001_csharp.md) -- [Store and retrieve data](./002_Store_retrieve_data_using_literal_and_variable/002_csharp.md) -- [Basic String Formating](./003_Basic_string_formatting/003_csharp.md) -- [Basic operations on numbers](./004_Basic_operation_on_numbers/004_csharp.md) -- [Calculate and print student grades](./005_Calc_and_print_grades/005_csharp.md) -- [Calculate students final GPA](./006_Calc_final_GPA/006_csharp.md) -- [Call methods from the .NET Class Library](./007_Methods_net_class/007_csharp.md) -- [if and if else](./008_if_else/008_csharp.md) -- [array and foreach](./009_arrays_forearc/009_csharp.md) -- [Conventions](./010_conventions/010_csharp.md) -- [Guided Project - foreach](./011_foreach_array_1/011_csharp.md) -- [Challenge Project - foreach](./012_foreach_array_2/012_csharp.md) -- [Evaluate Boolean expressions](/013_eval_boolean_expressions/013_csharp.md) -- [Control variable scope and logic](/014_scope_and_logic/014_csharp.md) -- [switch case construct](./015_switch_case/015_csharp.md) -- [FizzBuzz Challenge](./016_Iterate_using_for_statement/016_csharp.md) -- [Looping logic using the do-while and while](./017_Looping_logic_using_do-while_and_while/017_csharp.md) -- [Conditional branching and looping](./018_Conditional_branching_and_looping/018_csharp.md) -- [Branching and looping structures](./019_branching_and_looping_structures/019_csharp.md) -- [Choose the correct data type](/020_data_types/020_csharp.md) +1. [First Code](./001_first_code/001_csharp.md) +2. [Store and retrieve data](./002_Store_retrieve_data_using_literal_and_variable/002_csharp.md) +3. [Basic String Formating](./003_Basic_string_formatting/003_csharp.md) +4. [Basic operations on numbers](./004_Basic_operation_on_numbers/004_csharp.md) +5. [Calculate and print student grades](./005_Calc_and_print_grades/005_csharp.md) +6. [Calculate students final GPA](./006_Calc_final_GPA/006_csharp.md) +7. [Call methods from the .NET Class Library](./007_Methods_net_class/007_csharp.md) +8. [if and if else](./008_if_else/008_csharp.md) +9. [array and foreach](./009_arrays_forearc/009_csharp.md) +10. [Conventions](./010_conventions/010_csharp.md) +11. [Guided Project - foreach](./011_foreach_array_1/011_csharp.md) +12. [Challenge Project - foreach](./012_foreach_array_2/012_csharp.md) +13. [Evaluate Boolean expressions](/013_eval_boolean_expressions/013_csharp.md) +14. [Control variable scope and logic](/014_scope_and_logic/014_csharp.md) +15. [switch case construct](./015_switch_case/015_csharp.md) +16. [FizzBuzz Challenge](./016_Iterate_using_for_statement/016_csharp.md) +17. [Looping logic using the do-while and while](./017_Looping_logic_using_do-while_and_while/017_csharp.md) +18. [Conditional branching and looping](./018_Conditional_branching_and_looping/018_csharp.md) +19. [Branching and looping structures](./019_branching_and_looping_structures/019_csharp.md) +20. [Choose the correct data type](./020_data_types/020_csharp.md) +21. [Convert data types](./021_Casting_and_conversion_techniques/021_csharp.md)