Forem: Zhenni Wu

Guide to breaking down and understanding C# errors

Zhenni Wu — Mon, 16 Dec 2024 19:45:58 +0000

Intro

In this blog, I’m going to mainly focus on deciphering C# errors and potential steps to solve them. As I mentioned in my last blog, C# is statically typed, which allows the compiler to perform more optimization work ahead of time. One of the important features of C# is how it’s compiled.

Compile Time is…

Compile time refers to the period when the source code is being translated into machine code or an intermediate language by a compiler before the program actually runs (or even gets executed). In C#, this process happens when you build (or compile) your application (like all the code). The compiler checks your code for syntax errors, type mismatches, and other issues that would prevent the program from running correctly.

Compile time versus runtime…

I also mentioned in my last blog that JavaScript does runtime checks. I want to highlight the biggest difference between these two: C# detects errors at compile time, before the program runs, while JavaScript detects errors at runtime, when the program is already running. In JavaScript, the code continues to execute until it reaches an error.

Example compile-time errors:

randomData = "abc abc";
Console.WriteLine(randomData); 
// Error: all variables must be declared before they are assigned a value. 

int a = 10; 
string b = "Hello"; 

a = b;
 // Error: types are strictly enforced, meaning you cannot assign a string directly to an int without explicitly converting it.

string result = a + b;  
// Concatenation of an integer with a string requires explicit conversion before the concatenation can happen.

The program won't compile due to the errors. The compiler will produce error messages indicating the type mismatch, likely along the lines of:

/home/ccuser/workspace/csharp-data-types-variables-handling-errors-csharp_v2/Program.cs(9,7): error CS0103: The name 'randomData' does not exist in the current context [/home/ccuser/workspace/csharp-data-types-variables-handling-errors-csharp_v2/e7-workspace.csproj]

We can break it down into 3 parts to read.
First, we have the full local path of the file where the error occurred, Program.cs. The numbers that follow in parentheses denote the line and character of the file responsible for the error, respectively. So, (9,7) indicates that the error is on line 9, starting at the 7th character (including spaces).

/home/ccuser/workspace/csharp-data-types-variables-handling-errors-csharp_v2/Program.cs(9,7): 
// Path to exact location separated from the next part by :

Next is the actual error, which will inform us what in our code is incorrect. Every kind of error in C# has a unique identifier, like “CS0103”, so that they can easily be found within the Microsoft documentation. This error indicates that a variable name was used without ever being defined:

error CS0103: The name 'randomData' does not exist in the current context

Finally, a C# program requires a special type of file using the .csproj extension. The .csproj file itself does not generate error messages directly, but it dictates the build and deployment of metadata for the project. Checking the .csproj file is a good step to diagnose and resolve any issues related to missing dependencies, incorrect settings, or build misconfiguration.

[/home/ccuser/workspace/csharp-data-types-variables-handling-errors-csharp_v2/e7-workspace.csproj]

Based on that, you can infer what the other two error messages look like:

Error CS0103: The randomData variable is not declared before use.
Error CS0029: You cannot assign a string (b) to an int (a) without explicit conversion.
Error CS0019: You cannot use the + operator to concatenate an int with a string without converting the int to a string first.

These messages will explain why the code can't compile and point to the specific lines where the errors occur. You will need to fix these issues to make the code work, but now you know what issues your code is facing.

Sometimes, we don’t even need to find a solution—the error message will tell us exactly what the problem is.

int score = 45 // error CS1002: ; expected 

/home/ccuser/workspace/csharp-data-types-variables-handling-errors-csharp_v2/Program.cs(9,21): error CS1002: ; expected [/home/ccuser/workspace/csharp-data-types-variables-handling-errors-csharp_v2/e7-workspace.csproj]

The procedure to resolve a C# error...

Receive the error and break it down
- First, identify the location of the error. Look for the file name, line number, and character position in the error message.
Read through the error message carefully
- Understand what the error is telling you. This will often include information about what’s wrong (e.g., undeclared variables, type mismatches, etc.).
Search for the error code in Microsoft documentation
- Go to the Microsoft documentation website, and use the error code (e.g., "CS0103") in the filter by title search bar to find the related documentation for that specific error.
Review the documentation and examples
- Carefully read the explanation and solution examples provided in the documentation to understand how to resolve the issue.
Apply the solution in your code
- Try the suggested solution or fix it in your own code. Make sure to test it and check if the error is resolved.

I hope this was helpful! Here’s a quick tip: Like JavaScript, C# variable names can contain letters, digits, and underscores, but not the dollar sign ($). While the compiler doesn’t enforce it, it’s also good practice to use camelCase, which is the standard convention in JavaScript.

Previous: First glance at C# from JS perspective
Up next: Coming soon…

First glance at C# from JS perspective

Zhenni Wu — Tue, 03 Dec 2024 16:30:36 +0000

My journey started with…

When I set out to create a project, my goal was to build a game that could potentially feature 3D elements, be interactive, and particularly played on mobile platforms. I also wanted to integrate AI into the game to add depth and complexity. Naturally, this led me to explore C#—a language commonly used in the Unity game engine. While I won’t dive into the specifics of Unity itself in this post, I do want to focus on why I chose C# and how it compares to JavaScript from my perspective as someone coming from a JavaScript background.

Why C#...

The primary reason I decided to use C# is that Unity, the game engine I chose, relies heavily on C# as its main programming language. While there are other languages you could potentially use in Unity, C# is by far the most widely supported and recommended. It's a modern, object-oriented programming language developed by Microsoft, and it's commonly used in a variety of applications, including desktop software, web applications (via ASP.NET), and—of course—games using Unity.
C# is part of the larger .NET ecosystem, which offers a huge library of resources and frameworks for building everything from small utilities to large-scale enterprise applications. The language itself was designed with simplicity, power, and type safety in mind. This makes it a versatile choice for many kinds of projects. But in this post, I want to focus particularly on the aspect of type safety and why it makes C# stand out, especially compared to JavaScript.

Why C# data type…

C# is a statically typed language, meaning that variable types (like int, bool, string) are defined at compile-time. Since C# is statically typed, the compiler can perform more optimization work ahead of time. Its type safety feature, with variable types being strictly defined, allows the compiler to catch many types of errors before the code is even run and helps the code be more maintainable. JavaScript, being dynamically typed, requires more runtime checks due to a process called type coercion, which adds overhead, especially in large or complex applications. This is part of the reason C# can be faster. However, the main performance edge of C# lies in compute-intensive and multithreaded tasks (like running different parts of the game in parallel).

JS type coercion:

let num = 5;
let str = "10";
console.log(num + str);  // Outputs "510" (string concatenation instead of numeric addition)
str = 10; // Assign a string to a variable and later assign a number to the same variable

Common C# declaration of value data type:

int x = 10; // Whole integer number
double pi = 3.14159; // Decimals 64-bit floating point, end with d but not necessary
float y  = 10.2f; // Decimals 32-bit floating point, have to end with f
decimal price = 19.99m; // 128-bit decimal, have to end with m, for precise monetary calculations or any financial stuff
bool isValid = true; //Boolean true or false
char grade = 'A'; //A single character, of 16-bit Unicode character
string name = "John"; //special case, is actually a reference type

As we know, in JavaScript, variables are declared with var, const, and let. Also, JavaScript has no distinction between int and float; it's just number. Therefore, C# doesn't have NaN. Additionally, in JavaScript, string is a primitive type (similar to a value type in C#), but in C#, it is a reference type.

In C#, value types cannot be null by default, but you can use nullable types to allow value types to be assigned null. null is allowed only for reference types (like string, object, and custom classes). By default, reference types are initialized to null. To enable value types to be nullable, you use the ? syntax (like int?, double?, bool?).

string name = null; // This is valid.
Person person = null; // This is also valid if 'Person' is a class.
int? number = null; // Explicitly allows null since nullable type is enabled
int number = null; // Error: Cannot assign null to a non-nullable value type

JavaScript does not have a concept of nullable types like C#; everything can technically be null or undefined.

In both languages, when dealing with reference types, any changes made to the data through one reference will affect all other references pointing to the same data in memory. However, C# is more strongly typed, and arrays are of fixed size unless you use collections like List<T>, while JavaScript arrays are more flexible and dynamic.
C# reference types: object, class, delegate, array.
JavaScript reference types: object, array, function.

C# Array (fixed size):

int[] numbers = new int[] { 1, 2, 3 };
numbers[3] = 4;  // Error: Index out of bounds because the array size is fixed

JS Array (dynamic size):

let numbers = [1, 2, 3];
numbers.push(4);  // Adds 4 to the end of the array, dynamically resizing it
console.log(numbers);  // [1, 2, 3, 4]

C# data conversion…

In C#, data conversion refers to the process of converting one data type to another, and it can be done in two main ways: implicit and explicit conversions.

Implicit conversions are automatic when converting from smaller to larger types, or when there's no risk of data loss.
Explicit conversions are done manually when there’s a risk of data loss (usually via casting).

C# also provides built-in Method for safe type conversions, especially when converting between types that might not automatically cast. Additionally, nullable types require extra handling to deal with null values. Proper data conversion is crucial to ensure data integrity, avoid runtime errors, and maintain performance when working with different data types in C#.

All in all, while JavaScript’s flexibility and dynamic nature make it great for quick prototyping and web development, C# has a clear performance edge when it comes to more complex or compute-intensive tasks. This is especially true in game development, where you may need to handle 3D graphics, AI, physics simulations, and other high-performance operations.
Remember to add your semicolons(;) to end every line of code in C#! I keep forgetting, but they’re strictly required in C#.
Here are a quick link to official documentation on Reserved keywords are words that the language uses, so they already have specific definitions that shouldn’t be rewritten

Up next: Guide to breaking down and understanding C# errors