# Converting Data Types in C# C# converts a smaller type to a larger one for you; anything else you convert yourself, with a cast, the Convert class, or Parse for text. Apprentice · C# · Updated November 3, 2026 ## After this lesson you can - Convert between numeric types with a cast or the Convert class - Turn text into a number with Parse or TryParse ## Key takeaways - C# converts for you only when the new type can hold every value, such as an `int` into a `long` or a `double`. - A cast such as `(int)hours` cuts off the decimals; `Convert.ToInt32` rounds. - A cast is a promise that the value fits. If it doesn't, you get a wrong number, not an error. - `int.Parse` and `decimal.Parse` turn text into a number; `TryParse` does it safely when the text might not be a number. Values often arrive as one type when you need another: a whole number you need to multiply by a price, or a number a user typed, which arrives as text. Converting between types is part of almost every calculation. ## Conversions C# makes for you C# converts a value automatically when the new type can hold it: when a *smaller* type fits into a *larger* one. ```csharp string name = "Gary"; int age = 27; // Text plus a number: C# turns the number into text and joins them Console.WriteLine(name + " is " + age); int gallonsInFishTank = 55; long gallonsInLake = 3000000000L; // An int fits in a long, so gallonsInFishTank becomes a long before adding long totalGallons = gallonsInFishTank + gallonsInLake; Console.WriteLine(totalGallons); ``` ```text Gary is 27 3000000055 ``` These conversions always work, so C# makes them for you: - `byte` into `short`, `int` or `long` - `short` into `int` or `long` - `int` into `long`, `double` or `decimal` - `long` into `double` or `decimal` - `float` into `double` (One small catch: a `long` bigger than about 9 quadrillion can lose its last few digits when it becomes a `double`. You won't meet numbers that big in this course.) The other direction is not automatic. Even when the value is small, C# will not put a `long` into an `int`, because another value might not fit: ```csharp long bigAge = 18; // This line does not compile: a long might not fit in an int int age = bigAge; ``` The compiler stops with an error like `Cannot implicitly convert type 'long' to 'int'`. When you know the value fits, you convert it yourself. ## Casting A **cast** tells C# which type you want. Write the type in parentheses in front of the value: ```csharp long bigAge = 18; int age = (int)bigAge; double price = 7.99; int wholeDollars = (int)price; Console.WriteLine(age); Console.WriteLine(wholeDollars); ``` ```text 18 7 ``` Casting a `double` to an `int` doesn't round. It cuts off everything after the decimal point, so 7.99 becomes 7. A cast is a promise that the value fits. If it doesn't, C# keeps the promise anyway, and you get a wrong answer with no warning: ```csharp long manyGallons = 3000000000L; int gallons = (int)manyGallons; Console.WriteLine(gallons); ``` ```text -1294967296 ``` 3 billion is bigger than the largest `int` (about 2.1 billion), so the number wrapped around past the top and came back negative. Cast only when you are sure the value fits. ## The Convert class The `Convert` class has a method for each type, such as `Convert.ToInt32` for `int` (32 is how many bits an `int` uses) and `Convert.ToDecimal`. Unlike a cast, it rounds to the nearest whole number instead of cutting off: ```csharp double hoursWorked = 7.6; int byCast = (int)hoursWorked; int byConvert = Convert.ToInt32(hoursWorked); Console.WriteLine("Cast: " + byCast); Console.WriteLine("Convert: " + byConvert); ``` ```text Cast: 7 Convert: 8 ``` `Convert` also refuses to wrap around. A value too big for the type stops the program with an error, which is better than a wrong answer you might not notice. ## double and decimal don't mix `double` and `decimal` both hold decimals, but they store them differently, so C# won't calculate with one of each. Convert one first: ```csharp double areaInSquareFeet = 128.5; decimal pricePerSquareFoot = 5.25m; // pricePerSquareFoot * areaInSquareFeet would not compile decimal totalCost = pricePerSquareFoot * (decimal)areaInSquareFeet; Console.WriteLine(totalCost); ``` ```text 674.625 ``` ## Turning text into a number Text that looks like a number is still text. Adding to it joins, it doesn't add: ```csharp string age = "25"; Console.WriteLine(age + 1); ``` ```text 251 ``` To calculate with it, turn the text into a number. Each number type has a `Parse` method: ```csharp string ageText = "25"; int age = int.Parse(ageText); Console.WriteLine(age + 1); string priceText = "15.50"; decimal price = decimal.Parse(priceText); decimal discount = price * 0.1m; Console.WriteLine("The 10% discount is " + discount); ``` ```text 26 The 10% discount is 1.550 ``` `Parse` stops the program with an error when the text isn't a number, such as `"twenty"`. When the text comes from a person, who can type anything, use `TryParse`. It returns `true` or `false` instead of stopping, and puts the number in a variable you name after `out`: ```csharp string typed = "twenty"; bool isNumber = int.TryParse(typed, out int quantity); Console.WriteLine("Is it a number? " + isNumber); Console.WriteLine("Quantity: " + quantity); ``` ```text Is it a number? False Quantity: 0 ``` When the text isn't a number, `quantity` is 0 and `isNumber` is `false`, so your program can ask again. You will do exactly that once you can make decisions with `if`. ## Turning a number into text Every value has a `ToString` method, which gives its value as text. You have been using it without seeing it: joining a number to text with `+` calls `ToString` for you. ```csharp int score = 42; string scoreText = score.ToString(); Console.WriteLine(scoreText + " points"); ``` ```text 42 points ``` ## Check yourself 2 questions to try on the lesson page. ## So what C# converts for you only when the new type can hold the value. Everywhere else, you choose: a cast when you know the value fits, `Convert` when you want rounding and a safety check, and `Parse` or `TryParse` when the value arrives as text. ## Key terms - [Type Conversion](https://www.ask-codey.com/glossary/type-conversion-c-sharp) - [Type Casting](https://www.ask-codey.com/glossary/type-casting-c-sharp) - [Parse()](https://www.ask-codey.com/glossary/parse) - [TryParse()](https://www.ask-codey.com/glossary/tryparse) ## Cheat sheets - [Converting Data Types in C#](https://www.ask-codey.com/cheat-sheets/converting-data-types-in-csharp-cheat-sheet) Source: https://www.ask-codey.com/lessons/converting-data-types-in-csharp