Hey guys! Are you ready to dive into the world of .NET Core and C#? If so, you've come to the right place. This tutorial is designed to guide you through the basics of .NET Core using the practical, hands-on approach that W3Schools is known for. Whether you're a complete beginner or have some programming experience, this will help you get up and running with .NET Core quickly. So, let's get started!

What is .NET Core?

.NET Core is a cross-platform, open-source framework for building modern, cloud-based, and modular applications. It's the successor to the .NET Framework, designed to be more flexible and efficient. With .NET Core, you can develop applications that run on Windows, macOS, and Linux. This makes it a fantastic choice for building applications that need to reach a wide audience.

Key Features of .NET Core

1. Cross-Platform Compatibility: One of the most significant advantages of .NET Core is its ability to run on different operating systems. This is a game-changer because you’re no longer tied to a single platform. Write your code once, and deploy it on Windows, macOS, or Linux. This flexibility is crucial in today's diverse tech landscape.
2. Open Source: .NET Core is open source, which means its source code is available on GitHub. This transparency allows developers to contribute to the framework, report issues, and customize it to suit their needs. The open-source nature fosters a collaborative environment, leading to continuous improvements and innovations.
3. Modularity: .NET Core is designed with a modular architecture. Instead of installing a large, monolithic framework, you can include only the components you need for your application. This results in smaller application sizes, faster deployment times, and reduced resource consumption. Modularity also simplifies updates and maintenance.
4. High Performance: .NET Core is engineered for high performance. It includes a streamlined runtime and optimized libraries that enable applications to run faster and more efficiently. This is particularly important for web applications and services that need to handle a large number of concurrent requests.
5. Modern Application Development: .NET Core supports modern application development paradigms, such as microservices, containers, and cloud-native architectures. It integrates well with popular tools and technologies like Docker, Kubernetes, and Azure, making it easy to build and deploy scalable and resilient applications.

Setting Up Your Environment

Before we start coding, you'll need to set up your development environment. Here’s a step-by-step guide to get you ready:

Install the .NET Core SDK

First, download the .NET Core SDK (Software Development Kit) from the official Microsoft website. Make sure to choose the version that matches your operating system (Windows, macOS, or Linux). The SDK includes everything you need to develop, build, and run .NET Core applications.

• Windows: Download the installer and follow the on-screen instructions. Once installed, open a new command prompt or PowerShell window to ensure the .NET Core commands are available.
• macOS: Download the .pkg installer and follow the instructions. After installation, verify that .NET Core is correctly installed by opening a terminal and running the dotnet --version command.
• Linux: Follow the instructions provided on the Microsoft website for your specific distribution. This usually involves adding the Microsoft package repository to your system and installing the .NET Core SDK using your distribution’s package manager.

Choose an IDE

An Integrated Development Environment (IDE) can make coding much easier and more efficient. Here are a couple of popular options:

• Visual Studio: Visual Studio is a powerful IDE from Microsoft that provides a rich set of features for .NET Core development, including IntelliSense, debugging tools, and project templates. It’s available for Windows and macOS.
• Visual Studio Code: Visual Studio Code (VS Code) is a lightweight but powerful code editor that supports .NET Core development through extensions. It’s available for Windows, macOS, and Linux, and it’s free to use.

For this tutorial, we’ll be using Visual Studio Code because it’s cross-platform and easy to set up. Download and install VS Code from the official website. Then, install the C# extension from the VS Code marketplace to get syntax highlighting, IntelliSense, and other helpful features.

Verify Your Installation

To make sure everything is set up correctly, open a terminal or command prompt and run the following command:

dotnet --version

This should display the version of the .NET Core SDK that you installed. If you see a version number, you’re good to go!

Your First .NET Core Application

Let's create a simple "Hello, World!" application to get a feel for .NET Core development. Follow these steps:

Create a New Project

Open a terminal or command prompt and navigate to the directory where you want to create your project. Then, run the following command:

dotnet new console -o HelloWorld
cd HelloWorld

This command creates a new console application project named “HelloWorld” and navigates into the project directory.

Write the Code

Open the Program.cs file in your IDE (Visual Studio Code). You should see something like this:

using System;

namespace HelloWorld
{
 class Program
 {
 static void Main(string[] args)
 {
 Console.WriteLine("Hello World!");
 }
 }
}

This is the basic structure of a .NET Core console application. The Main method is the entry point of the application. In this case, it simply prints "Hello World!" to the console.

Run the Application

To run the application, execute the following command in the terminal:

dotnet run

You should see "Hello World!" printed in the console. Congratulations, you've just run your first .NET Core application!

Basic C# Concepts

Now that you've created a simple application, let's dive into some basic C# concepts. C# is the primary programming language used for .NET Core development, so it’s important to understand its fundamentals.

Variables and Data Types

In C#, a variable is a storage location that holds a value. Each variable has a data type, which specifies the kind of value it can store. Here are some common data types:

• int: Represents a 32-bit integer.
• double: Represents a double-precision floating-point number.
• string: Represents a sequence of characters.
• bool: Represents a boolean value (true or false).

Here’s how you can declare and initialize variables in C#:

int age = 30;
double price = 19.99;
string name = "John Doe";
bool isStudent = true;

Control Structures

Control structures allow you to control the flow of execution in your program. Here are some common control structures:

• if statement: Executes a block of code if a condition is true.
• else statement: Executes a block of code if the condition in the if statement is false.
• for loop: Executes a block of code repeatedly for a specific number of times.
• while loop: Executes a block of code repeatedly as long as a condition is true.

Here are some examples:

if (age >= 18)
{
 Console.WriteLine("You are an adult.");
}
else
{
 Console.WriteLine("You are a minor.");
}

for (int i = 0; i < 10; i++)
{
 Console.WriteLine(i);
}

int count = 0;
while (count < 5)
{
 Console.WriteLine(count);
 count++;
}

Methods

A method is a block of code that performs a specific task. It can take input parameters and return a value. Here’s how you can define a method in C#:

static int Add(int a, int b)
{
 return a + b;
}

This method takes two integer parameters (a and b) and returns their sum. You can call this method like this:

int result = Add(5, 3);
Console.WriteLine(result); // Output: 8

Working with Classes and Objects

C# is an object-oriented programming language, which means it’s based on the concept of objects. An object is an instance of a class, and a class is a blueprint for creating objects. Let's see how to work with classes and objects in C#.

Defining a Class

To define a class, you use the class keyword followed by the name of the class. Inside the class, you can define fields (variables) and methods (functions) that belong to the class.

class Person
{
 public string Name { get; set; }
 public int Age { get; set; }

 public void Introduce()
 {
 Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
 }
}

In this example, we’ve defined a class called Person with two properties: Name (a string) and Age (an integer). We’ve also defined a method called Introduce that prints a message to the console.

Creating Objects

To create an object of a class, you use the new keyword followed by the class name and parentheses.

Person person = new Person();
person.Name = "Alice";
person.Age = 25;
person.Introduce(); // Output: Hello, my name is Alice and I am 25 years old.

In this example, we’ve created an object of the Person class and assigned values to its Name and Age properties. Then, we called the Introduce method to print a message to the console.

Conclusion

So there you have it! A comprehensive introduction to .NET Core using the straightforward, practical approach that W3Schools is known for. We've covered the basics of setting up your environment, creating your first application, and understanding fundamental C# concepts. With this knowledge, you’re well-equipped to start building more complex and exciting applications with .NET Core.

Keep practicing, keep exploring, and don't be afraid to experiment. The world of .NET Core is vast and full of opportunities. Happy coding, and see you in the next tutorial!