Microsoft Visual C# Step-by-Step John Sharps PDF

Microsoft Visual C# Step by Step John Sharp PDF: Dive into the world of C# programming with this comprehensive guide. This resource, meticulously crafted, promises a structured and engaging learning journey. From foundational syntax to advanced object-oriented concepts, and practical application examples, this PDF is your key to unlocking the power of C#. Imagine transforming ideas into functional programs—this PDF makes it happen, step by step.

This resource offers a clear path to mastering C#, covering everything from basic data types and operators to sophisticated object-oriented programming techniques. Whether you’re a complete beginner or seeking to enhance your C# skills, this resource provides a detailed, practical approach to programming in C#. The PDF’s step-by-step format ensures you grasp each concept firmly before moving on. It includes comparisons with other popular languages like Java and Python, helping you appreciate C#’s unique strengths.

Introduction to C# Programming

C# (pronounced “C-sharp”) is a powerful, modern, and versatile programming language developed by Microsoft. It’s object-oriented, meaning it’s designed to model real-world entities and their interactions using classes and objects. This makes it exceptionally well-suited for a wide range of applications, from building interactive websites and mobile apps to developing complex desktop software and game engines. Its strong typing and robust framework offer developers a secure and efficient environment for creating high-quality software.Learning C# step-by-step is crucial for anyone aspiring to become a proficient programmer.

A structured approach, like a comprehensive PDF, provides a clear roadmap, breaking down complex concepts into manageable, digestible chunks. This allows for focused learning and avoids the common pitfalls of overwhelming beginners with too much information at once. It builds a strong foundation, enabling you to progressively master more intricate programming techniques.

Importance of a Structured Learning Approach

A structured learning approach, such as the one provided in a well-organized PDF, is invaluable. It provides a clear path, guiding you through the fundamentals to advanced topics. This method helps you grasp concepts more readily and avoid common errors. Furthermore, the structured approach allows for consistent reinforcement of previously learned material, fostering a deeper understanding and ultimately improving your programming skills.

Comparing C# to Other Programming Languages

A comparison table helps illustrate C#’s unique strengths. Consider this comparison to Java and Python, two popular programming languages:

Feature	C#	Java	Python
Typing	Strongly Typed	Strongly Typed	Dynamically Typed
Platform	Primarily .NET	Platform Independent (using JVM)	Platform Independent
Focus	General Purpose, .NET Framework	General Purpose, Wide range of applications	General Purpose, scripting and data science
Syntax	Modern, C-like	Modern, C-like	Readable, plain English

This table highlights key distinctions. While Java is platform-independent, C# excels within the .NET ecosystem. Python’s dynamic typing provides flexibility but can lead to runtime errors if not carefully managed. C#’s strong typing and .NET framework offer robust features and performance, particularly for applications requiring high reliability and efficiency.

Benefits of Using a Learning Resource Like “John Sharp’s PDF”

“John Sharp’s PDF” offers a wealth of advantages. It provides clear explanations, practical examples, and step-by-step guidance. The well-organized format makes it easy to navigate, and the structured approach allows for consistent learning progress. Its detailed explanations, paired with examples, provide a solid understanding of C# principles, accelerating your learning curve. You can expect a clear roadmap to becoming a C# programmer.

Fundamentals of C# Syntax

C# syntax, the set of rules governing how you write C# code, is crucial for any programmer. Understanding these rules allows you to craft programs that the compiler can easily interpret and execute. This section will detail fundamental syntax elements, from basic data types to powerful conditional statements and loops.C# is designed to be readable and maintainable. Its syntax is quite similar to other popular languages, which makes it easier for developers to learn.

This approach helps you focus on the logic and problem-solving aspects of programming rather than getting bogged down in complex syntax.

Data Types

Data types define the kind of values a variable can hold. Different data types have different storage requirements, influencing the program’s efficiency. Choosing the right data type is vital to prevent unexpected behavior.

• C# offers various built-in data types, including integer types (like `int`, `short`, `long`), floating-point types (like `float`, `double`), and character types (like `char`). Strings, represented by the `string` type, are used to store sequences of characters. Boolean types, using `bool`, store true or false values. The `decimal` type provides high precision for monetary or financial calculations.

Variables

Variables are named storage locations that hold data. Declaring a variable involves specifying its data type and name. Assigning a value to a variable gives it a concrete content.

• Example: `int age = 30;` declares an integer variable named `age` and assigns the value 30 to it. `string name = “John”;` declares a string variable named `name` and initializes it with the string “John”.

Operators

Operators perform actions on data. Arithmetic operators (+, -,-, /, %) perform calculations. Relational operators (==, !=, >, <, >=, <=) compare values. Logical operators (&&, ||, !) combine conditions. Assignment operators (=, +=, -=, -=, /=, %=) assign values.

Operator	Description	Example
+	Addition	5 + 3 = 8
–	Subtraction	10 – 2 = 8
*	Multiplication	4 – 5 = 20
/	Division	12 / 3 = 4
%	Modulo (remainder)	10 % 3 = 1

Conditional Statements

Conditional statements control the flow of execution based on conditions. `if-else` statements allow for different code blocks to execute depending on whether a condition is true or false.

• Example:
  “`C#
  if (age >= 18)

  Console.WriteLine(“You are an adult.”);

  else

  Console.WriteLine(“You are a minor.”);

  “`

Loops

Loops repeatedly execute a block of code as long as a condition is met. `for` loops are suitable for iterating a set number of times, while `while` loops repeat as long as a condition remains true.

• Example:
  “`C#
  for (int i = 0; i < 5; i++) Console.WriteLine(i); ```

Data Type Sizes

The size of a data type affects memory usage and computational efficiency.

Data Type	Size (approximately)	Description
`int`	4 bytes	Stores whole numbers
`float`	4 bytes	Stores single-precision floating-point numbers
`double`	8 bytes	Stores double-precision floating-point numbers
`char`	2 bytes	Stores a single character

Object-Oriented Programming (OOP) Concepts in C#

C# embraces object-oriented programming (OOP), a powerful paradigm that structures code around “objects.” These objects encapsulate data and the methods that operate on that data, promoting modularity, reusability, and maintainability. This approach fosters cleaner, more organized, and often more efficient codebases, especially in complex applications. Mastering OOP principles is a key step in becoming a proficient C# developer.OOP in C# revolves around four fundamental concepts: encapsulation, inheritance, polymorphism, and abstraction.

We’ll explore each of these pillars, demonstrating how they work together to build robust and adaptable applications. Let’s dive into the world of C# objects!

Encapsulation

Encapsulation bundles data (variables) and the methods that operate on that data within a class. This approach promotes data hiding, where internal data is protected from direct external access. Instead, methods provide controlled access and manipulation. This protects data integrity and simplifies maintenance.

Inheritance

Inheritance allows a class (derived class) to inherit properties and methods from another class (base class). This fosters code reuse and establishes a hierarchical relationship between classes. Think of it as a blueprint where a new class builds upon the foundation of an existing one.

Polymorphism

Polymorphism, meaning “many forms,” allows objects of different classes to be treated as objects of a common type. This enables flexibility in handling objects from various classes using a unified interface. C# achieves this through method overriding, where derived classes provide their own implementations of methods inherited from the base class.

Defining Classes and Objects

A class acts as a blueprint for creating objects. To define a class, you specify the data (variables) and methods (functions) that will be part of objects created from that class.“`C#public class Dog public string Name; public int Age; public void Bark() Console.WriteLine(“Woof!”); “`This example defines a `Dog` class with `Name` and `Age` properties.

The `Bark()` method represents a behavior associated with a dog. Objects of this class can store information about specific dogs.

Creating Methods and Constructors

Methods define the actions an object can perform. Constructors initialize objects when they are created.“`C#public class Dog public string Name; public int Age; public Dog(string name, int age) // Constructor Name = name; Age = age; public void Bark() Console.WriteLine(“Woof! My name is ” + Name); “`This enhanced `Dog` class includes a constructor that sets the `Name` and `Age` of a `Dog` object when it’s created.

The `Bark()` method now includes the dog’s name in its output.

Inheritance and Derived Classes

Derived classes extend base classes, inheriting their properties and methods. This allows for specialization and code reuse.“`C#public class GoldenRetriever : Dog public string Color; public GoldenRetriever(string name, int age, string color) : base(name, age) // Constructor Color = color; public new void Bark() // Method overriding Console.WriteLine(“Woof! A golden retriever barks!”); “`The `GoldenRetriever` class inherits from the `Dog` class, adding a `Color` property.

The constructor initializes the new property, and the `Bark()` method is overridden to provide a specific message.

Polymorphism using Method Overriding

Method overriding allows derived classes to provide specific implementations of methods inherited from base classes. This enables polymorphism.“`C#Dog myDog = new Dog(“Buddy”, 3);GoldenRetriever myGoldenRetriever = new GoldenRetriever(“Max”, 2, “Golden”);myDog.Bark(); // Output: Woof! My name is BuddymyGoldenRetriever.Bark(); // Output: Woof! A golden retriever barks!“`The code demonstrates how different objects, though related through inheritance, can respond differently to the same method call.

This flexibility is key to creating adaptable and maintainable code.

Working with Data in C#

C# provides a rich ecosystem for handling data, making it a powerful language for various applications. From simple lists to complex data structures, C# empowers developers to efficiently store, manipulate, and retrieve information. Understanding these techniques is crucial for building robust and scalable software.C# offers diverse ways to manage data, allowing you to tailor your approach to specific needs.

This section delves into arrays, lists, dictionaries, and LINQ, providing insights into their functionalities and practical applications. By mastering these techniques, you can craft more effective and organized code.

Arrays

Arrays are fundamental data structures that store collections of elements of the same data type. They are useful when you know the exact size of the data beforehand. Their fixed size can lead to efficiency in accessing elements.

• Declaration and Initialization: Arrays are declared with the data type followed by square brackets containing the size. Initialization can happen during declaration or separately.
• Accessing Elements: Elements are accessed using their index (position) within the array, starting from zero.
• Example: Consider an array to store 5 student scores. `int[] scores = new int[5] 85, 92, 78, 95, 88 ;` Accessing the third score involves `scores[2]`, which yields 78.
• Important Note: Array indexes are zero-based. The first element is at index 0, the second at index 1, and so on.

Lists

Lists are dynamic arrays, meaning their size can change during runtime. This flexibility makes them ideal for scenarios where the exact amount of data isn’t known in advance.

• Dynamic Resizing: Lists automatically adjust their capacity to accommodate new elements, ensuring efficient memory management.
• Adding and Removing Elements: Methods like `Add()` and `Remove()` facilitate easy modification of the list’s content.
• Example: Imagine a shopping list. You can add items to the list (`shoppingList.Add(“Milk”)`), and remove items as you buy them (`shoppingList.Remove(“Eggs”)`).
• Iteration: Lists can be traversed using loops or LINQ queries, allowing for flexible data retrieval.

Dictionaries

Dictionaries store data in key-value pairs. This structured approach is excellent for storing and retrieving data associated with unique identifiers.

• Key-Value Pairs: Each element in a dictionary is a key-value pair, enabling fast lookups based on the key.
• Unique Keys: Keys in a dictionary must be unique; duplicate keys are not allowed.
• Example: A phone book could use a dictionary to store names (keys) and phone numbers (values).
• Retrieving Values: You can efficiently access values associated with specific keys.

LINQ (Language Integrated Query)

LINQ allows querying data from various sources, including arrays and lists, using a C# syntax. This enhances code readability and makes data manipulation easier.

• Query Syntax: LINQ provides a familiar query syntax that mirrors SQL, making it intuitive for developers familiar with relational databases.
• Method Syntax: LINQ also offers a method-based syntax for querying, offering flexibility and different functional programming styles.
• Data Manipulation: LINQ simplifies tasks such as filtering, sorting, grouping, and projecting data from collections.
• Example: To filter students with scores above 90 from a list, LINQ provides a concise and expressive way to achieve this.

Data Structure Performance

The choice of data structure significantly impacts the performance of your application. Understanding their characteristics is vital for optimization.

• Array: Arrays offer fast element access due to their contiguous memory allocation. However, adding or removing elements can be slow due to the need for potentially reallocating memory.
• List: Lists excel at dynamic resizing and adding/removing elements, but element access might be slightly slower compared to arrays.
• Dictionary: Dictionaries provide the fastest retrieval based on keys, making them ideal for lookups. However, iteration might be less efficient than with arrays or lists.
• Choosing the right data structure for your needs will optimize application speed and efficiency.

Input/Output Operations in C#

C# shines when it comes to interacting with the outside world. From reading user input to writing data to files, C#’s input/output capabilities are robust and versatile. This section dives deep into the world of file handling and console interaction, arming you with the knowledge to create powerful applications.Understanding how to efficiently read and write data is crucial for any C# developer.

From simple text files to complex binary formats, this section will equip you with the skills to handle various file types and understand the role of streams in file I/O. We’ll also explore ways to interact with users through the console, providing a clear and interactive experience.

Reading and Writing Files

File I/O in C# leverages the power of streams, providing a flexible and efficient way to work with data stored in files. Reading from and writing to files requires careful consideration of the file format. This section will demonstrate how to handle both text and binary files, showcasing the appropriate approaches for each.

• Text Files: Reading text files involves using the `StreamReader` class. The `StreamReader` class reads data from the file as a stream of characters. The `ReadLine()` method allows you to read each line from the file. For example, to read all lines from a file named “data.txt”:

  “`C#
  using System.IO;

  string filePath = “data.txt”;
  try

  using (StreamReader reader = new StreamReader(filePath))

  string line;
  while ((line = reader.ReadLine()) != null)

  Console.WriteLine(line);

  catch (FileNotFoundException)

  Console.WriteLine($”File ‘filePath’ not found.”);

  catch (Exception ex)

  Console.WriteLine($”An error occurred: ex.Message”);

  “`
  This example demonstrates how to handle potential errors like the file not being found, ensuring your application remains robust.

• Binary Files: Binary files are typically used for storing data in a non-text format. Reading binary files involves using the `BinaryReader` class, which allows you to read data in various binary formats. This provides more control over the data being read.
  “`C#
  using System.IO;

  string filePath = “data.bin”;
  try

  using (BinaryReader reader = new BinaryReader(File.Open(filePath, FileMode.Open)))

  // Read data based on the binary format.
  int intValue = reader.ReadInt32();
  Console.WriteLine($”Integer value: intValue”);

  catch (FileNotFoundException ex)

  Console.WriteLine($”File ‘filePath’ not found.”);

  catch (Exception ex)

  Console.WriteLine($”An error occurred: ex.Message”);

  “`
  This snippet illustrates how to read binary data. Remember to adjust the reading methods (`ReadInt32`, `ReadDouble`, etc.) based on the specific data type stored in your binary file.

Console Input/Output

Interacting with the user through the console is a fundamental part of many applications. This section covers methods for receiving user input and displaying output.

• Reading Console Input: The `Console.ReadLine()` method is used to read a line of text from the console. This is a straightforward way to get input from the user.

  “`C#
  Console.WriteLine(“Enter your name:”);
  string name = Console.ReadLine();
  Console.WriteLine($”Hello, name!”);
  “`
  This code snippet demonstrates a simple input and output interaction with the user.

• Writing Console Output: C# provides several methods for displaying information on the console. The `Console.WriteLine()` method writes a line of text to the console. `Console.Write()` is also available for writing output without a newline.
  “`C#
  Console.WriteLine(“This will print on a new line.”);
  Console.Write(“This will print on the same line.”);
  “`
  This illustrates how to write text to the console using `WriteLine` and `Write`.

Common C# Libraries and Tools

C# boasts a rich ecosystem of libraries and tools, making it incredibly versatile. These resources streamline development, allowing you to tackle complex tasks efficiently. From handling dates and times to interacting with files, these libraries are crucial to mastering C#. Learning to leverage them is a significant step toward becoming a proficient C# developer.

Essential C# Libraries

C# offers a vast collection of libraries, meticulously designed to handle various tasks. These libraries, often organized into namespaces, provide pre-built functions and classes, reducing development time and enhancing code maintainability. Familiarity with these libraries is fundamental for effective C# programming.

String Manipulation

The `System.String` class and related libraries are fundamental for string manipulation. These provide methods for searching, replacing, splitting, and formatting strings. Efficient string handling is critical for tasks like data validation, user input processing, and text manipulation within applications. For instance, extracting specific data from user input, parsing log files, or constructing user-friendly messages all rely on string manipulation techniques.

Date and Time Handling

The `System.DateTime` class and its associated methods provide a powerful toolkit for working with dates and times. These libraries allow for date arithmetic, formatting, parsing, and comparisons, essential for tasks like scheduling, record keeping, and time-sensitive applications. Imagine an application that needs to calculate the difference between two dates or display a date in a specific format – these libraries make such tasks straightforward.

File System Interaction

C# offers robust libraries for interacting with the file system. These libraries enable operations like reading and writing files, creating directories, and managing file attributes. This is crucial for applications requiring data persistence, file processing, or file system management. For example, a file-based database application or a document processing program would extensively use these functionalities.

Useful C# Libraries Table

Library	Purpose
`System.String`	String manipulation, searching, replacing, formatting
`System.DateTime`	Date and time handling, arithmetic, formatting, parsing
`System.IO`	File system interaction, file reading, writing, directory management
`System.Collections.Generic`	Working with collections (lists, dictionaries, etc.)
`System.Linq`	Data querying and manipulation

Namespaces

Namespaces organize C# code into logical groups, preventing naming conflicts and improving code readability. They are essential for structuring large projects. For example, consider a project with multiple modules. Namespaces help separate and organize the code in a structured manner. Within a namespace, you can declare classes, methods, and variables.

Namespace prefixes provide a way to uniquely identify elements within the namespace hierarchy.

.NET Framework and .NET Core

The .NET Framework and .NET Core provide the runtime environment for C# code. The .NET Core is a cross-platform, open-source framework, while the .NET Framework is a Microsoft-specific framework. They both provide a vast collection of libraries and tools. Choosing between the two often depends on the specific needs of the application and the target environment. Understanding these frameworks is crucial for deploying and running C# applications.

Example: Working with Dates

“`C#using System;public class DateExample public static void Main(string[] args) DateTime now = DateTime.Now; Console.WriteLine($”Current date and time: now”); DateTime tomorrow = now.AddDays(1); Console.WriteLine($”Tomorrow’s date: tomorrow”); “`This simple example demonstrates how to get the current date and time, and calculate tomorrow’s date using the `DateTime` class.

Such functionality is vital for many applications.

Practical Applications of C#

C# isn’t just a language; it’s a powerful tool for building a wide array of applications. From simple utilities to complex enterprise solutions, C# shines. This section dives into the practical applications, demonstrating how to build functional programs using C# and its features.The practical application of C# extends beyond the theoretical realm. We’ll explore examples demonstrating how C# code translates into real-world functionality, highlighting the versatility and efficiency of the language.

Simple Calculator Application

A calculator is a perfect starting point for illustrating fundamental C# programming concepts. This application will focus on basic arithmetic operations.

• The program will take two numbers as input from the user.
• It will then prompt the user to select an operation (addition, subtraction, multiplication, or division).
• The program will perform the chosen operation and display the result.

Text Editor Application

Building a rudimentary text editor demonstrates handling files and user input.

• The application will allow users to open and save text files.
• It will enable users to perform basic text editing operations like cut, copy, and paste.
• Error handling for file operations will be crucial for a robust application.

Using Windows Forms Controls

Windows Forms applications leverage visual controls for user interaction. Understanding how to effectively use these controls is key to creating intuitive and user-friendly applications.

• Buttons: These controls trigger actions when clicked.
• Text boxes: These allow users to input text data.
• Labels: These display static text or messages.
• ComboBoxes: These provide a list of options for the user to select.
• Combining these controls will create an application with a graphical user interface (GUI).

Handling Events in C#

Event handling is crucial for responsive applications. Understanding events allows you to create applications that react dynamically to user input or other changes.

• Events occur when specific actions take place (like a button click).
• Event handlers are special methods that respond to these events.
• Implementing event handlers makes applications interactive and dynamic.

Building a Simple Application (Step-by-Step)

Let’s illustrate the process with a simple “greeting” application.

1. Create a new Windows Forms Application project in Visual Studio.
2. Add a button control to the form.
3. Double-click the button to create an event handler for the Click event.
4. Write code within the event handler to display a greeting message in a label control.
5. Run the application and click the button to see the result.

Debugging and Troubleshooting in C#

Unveiling the secrets to smooth sailing in your C# programming journey often hinges on mastering the art of debugging. Troubleshooting isn’t about avoiding problems; it’s about understanding them, learning from them, and ultimately, becoming a more efficient and effective developer. This section will guide you through common pitfalls, effective debugging tools, and strategic techniques to ensure your code runs flawlessly.

Common C# Errors and Identification, Microsoft visual c# step by step john sharp pdf

Identifying the source of errors is crucial in the debugging process. Common C# errors include syntax errors, runtime errors, and logic errors. Syntax errors are easily detected by the compiler, while runtime errors occur during program execution. Logic errors, however, can be trickier to spot, often manifesting as unexpected program behavior. A methodical approach to analyzing error messages and tracing program flow is essential.

Using Debugging Tools in Visual Studio

Visual Studio provides powerful debugging tools to help pinpoint the source of errors. These tools allow developers to step through code line by line, inspect variable values, and set breakpoints to pause execution at specific points. This hands-on approach is invaluable in understanding how your code behaves under various conditions.

Debugging Techniques

Several techniques can be employed to effectively troubleshoot errors. One is isolating the problematic section of code. Another technique is meticulously reviewing the code’s logic, ensuring that each step aligns with the intended outcome. Using print statements strategically can offer insights into the flow of data through the program. Employing unit testing to isolate code sections and systematically testing input values can help in detecting and resolving errors.

A combination of these approaches often proves highly effective.

Examples of Debugging Code

Consider a scenario where a program is supposed to calculate the sum of numbers in an array. If the program yields an incorrect result, a breakpoint placed at the line calculating the sum can help track variable values at that point. Stepping through the code line by line allows you to observe how variables change and identify any discrepancies.

Similarly, inspecting variable values during execution helps pinpoint the exact cause of the error.

Best Practices for Maintainable and Debuggable Code

Writing maintainable and debuggable code is a proactive approach to problem-solving. Using meaningful variable names, writing comments to clarify complex logic, and structuring code into logical blocks are essential for readability. Thorough testing and documentation are also crucial for long-term maintenance and debugging. Employing modular design helps in isolating code sections for testing and debugging. By adhering to these best practices, you can minimize the occurrence of errors and make debugging smoother.

Resource Recommendations: Microsoft Visual C# Step By Step John Sharp Pdf

Embarking on your C# journey is like setting sail on a vast ocean. The John Sharp PDF is a solid compass, but to truly navigate the complexities and discover hidden treasures, you need a well-stocked library of supplementary resources. These additional tools will equip you with a broader perspective and empower you to tackle more intricate projects.A robust learning strategy encompasses not just one source but a combination of approaches.

This involves exploring various mediums, comparing different styles, and ultimately choosing the ones that resonate with your learning preferences. Understanding the strengths and weaknesses of each resource is key to making informed decisions about your learning path.

Additional C# Tutorials and Courses

Various online platforms offer structured C# courses. These often provide interactive exercises and practical applications, complementing the theoretical knowledge found in the John Sharp PDF. Many platforms offer different levels of C# expertise. Consider the scope of the course and your current knowledge to find the perfect match.

Books on C# Programming

Books offer a detailed and in-depth exploration of C# concepts. Some delve into specific areas like game development or web applications. Look for books that resonate with your interests and provide practical examples to solidify your understanding. They often serve as comprehensive references that you can return to as your skills grow.

Online Communities and Forums

Engaging with online communities and forums provides an invaluable opportunity to connect with other learners and experienced programmers. These platforms allow you to ask questions, share your experiences, and receive feedback. Learning from others’ experiences and challenges can be highly effective in solidifying your knowledge.

Structured Learning Paths

Crafting a structured learning path can significantly enhance your C# journey. This involves prioritizing topics and dedicating time to mastering each concept. For instance, a path focusing on game development might begin with the fundamentals, then progress to graphics programming, and conclude with game design. This approach allows you to focus your efforts and ensure a cohesive learning experience.

Comparing Different Learning Resources

• Online Courses: Interactive, often include hands-on exercises, readily available, but may lack the depth of a book.
• Books: Comprehensive, in-depth coverage of topics, excellent for reference, but can be less interactive than courses.
• Online Communities: Offer real-time support and diverse perspectives, great for problem-solving and knowledge sharing, but require self-discipline to stay focused.

A well-rounded learning strategy combines the strengths of these resources, maximizing your chances of success. Consider a blend of interactive courses, comprehensive books, and active participation in online communities to accelerate your learning.

Recommended Resources Beyond the John Sharp PDF

• Microsoft Learn: Offers numerous C# tutorials, courses, and documentation.
• C# Corner: A comprehensive online resource with articles, tutorials, and code examples.
• “Programming C# 9” by Joseph Albahari and Ben Albahari: A highly regarded book for in-depth learning of C# 9 features.
• “C# in Depth” by Jon Skeet: A comprehensive book covering various aspects of C# programming.

These supplementary resources provide a wealth of knowledge and practical examples, enabling you to explore C# in more depth and build a strong foundation. Choosing resources that align with your learning style and interests is crucial to a rewarding learning experience.