Back to Course|6 hours|Beginner

.NET Core Fundamentals & Setup

Build a strong foundation in .NET Core development and cross-platform programming.

Progress: 0/6 topics completed0%

Select Topics Overview

.NET Core Introduction & History

Understand .NET Core's evolution, architecture, and its role in modern cross-platform development

Content by: Sunny Radadiya

.Net Developer

Connect

What is .NET Core?

.NET Core is a free, open-source, cross-platform framework for building modern applications. It's a redesign of .NET Framework that runs on Windows, macOS, and Linux, providing a unified development experience across platforms.

Key Features of .NET Core

•Cross-Platform: Runs on Windows, macOS, and Linux
•Open Source: Fully open-source with community contributions
•High Performance: Optimized for cloud and containerized scenarios
•Unified Platform: Single codebase for multiple platforms
•Modern Development: Built-in dependency injection, configuration, and logging
•Cloud-Native: Designed for microservices and cloud deployment
•Container Support: Excellent Docker and Kubernetes integration

.NET Core vs .NET Framework

**Key Differences:** **Platform Support:** - .NET Core: Cross-platform (Windows, macOS, Linux) - .NET Framework: Windows-only **Deployment:** - .NET Core: Self-contained deployments, framework-dependent deployments - .NET Framework: Requires framework installation **Performance:** - .NET Core: Optimized for performance and memory usage - .NET Framework: Legacy performance characteristics **API Surface:** - .NET Core: Streamlined, modern APIs - .NET Framework: Larger, legacy API surface **Development:** - .NET Core: Modern tooling, CLI-first approach - .NET Framework: Visual Studio-centric development

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Cross-Platform Development

Learn how .NET Core enables true cross-platform development and deployment

Content by: Akash Vadher

.Net Developer

Connect

Platform-Specific Considerations

While .NET Core provides cross-platform capabilities, understanding platform-specific differences is crucial for building robust applications.

Cross-Platform Best Practices

•Use Path.Combine() instead of hardcoded path separators
•Handle case sensitivity differences between platforms
•Test on multiple target platforms
•Use environment variables for platform-specific configurations
•Leverage .NET Core's platform detection APIs
•Consider platform-specific native libraries carefully

Platform Detection Example

Code Example

using System;
using System.Runtime.InteropServices;

public class PlatformDetection
{
    public static void Main()
    {
        Console.WriteLine($"OS: {RuntimeInformation.OSDescription}");
        Console.WriteLine($"Architecture: {RuntimeInformation.OSArchitecture}");
        Console.WriteLine($"Process Architecture: {RuntimeInformation.ProcessArchitecture}");
        
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            Console.WriteLine("Running on Windows");
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            Console.WriteLine("Running on Linux");
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
        {
            Console.WriteLine("Running on macOS");
        }
    }
}

Swipe to see more code

using System;
using System.Runtime.InteropServices;

public class PlatformDetection
{
    public static void Main()
    {
        Console.WriteLine($"OS: {RuntimeInformation.OSDescription}");
        Console.WriteLine($"Architecture: {RuntimeInformation.OSArchitecture}");
        Console.WriteLine($"Process Architecture: {RuntimeInformation.ProcessArchitecture}");
        
        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            Console.WriteLine("Running on Windows");
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            Console.WriteLine("Running on Linux");
        }
        else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
        {
            Console.WriteLine("Running on macOS");
        }
    }
}

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

CLI Tools & Commands

Master the .NET Core CLI tools for project management, building, and deployment

Content by: Vaibhav Nakrani

.Net Developer

Connect

Essential .NET CLI Commands

The .NET CLI is a cross-platform toolchain for developing .NET applications. It provides commands for creating, building, running, and publishing applications.

Project Management Commands

Code Example

# Create a new project
dotnet new console -n MyApp
dotnet new webapi -n MyWebApi
dotnet new classlib -n MyLibrary

# Add packages
dotnet add package Newtonsoft.Json
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

# Remove packages
dotnet remove package Newtonsoft.Json

# List installed packages
dotnet list package

# Restore dependencies
dotnet restore

# Build the project
dotnet build

# Run the project
dotnet run

# Publish the project
dotnet publish -c Release -r win-x64 --self-contained true

Swipe to see more code

# Create a new project
dotnet new console -n MyApp
dotnet new webapi -n MyWebApi
dotnet new classlib -n MyLibrary

# Add packages
dotnet add package Newtonsoft.Json
dotnet add package Microsoft.EntityFrameworkCore.SqlServer

# Remove packages
dotnet remove package Newtonsoft.Json

# List installed packages
dotnet list package

# Restore dependencies
dotnet restore

# Build the project
dotnet build

# Run the project
dotnet run

# Publish the project
dotnet publish -c Release -r win-x64 --self-contained true

Scroll

Solution Management

Code Example

# Create a solution
dotnet new sln -n MySolution

# Add projects to solution
dotnet sln add MyApp/MyApp.csproj
dotnet sln add MyLibrary/MyLibrary.csproj

# Remove project from solution
dotnet sln remove MyApp/MyApp.csproj

# List solution projects
dotnet sln list

# Build entire solution
dotnet build MySolution.sln

Swipe to see more code

# Create a solution
dotnet new sln -n MySolution

# Add projects to solution
dotnet sln add MyApp/MyApp.csproj
dotnet sln add MyLibrary/MyLibrary.csproj

# Remove project from solution
dotnet sln remove MyApp/MyApp.csproj

# List solution projects
dotnet sln list

# Build entire solution
dotnet build MySolution.sln

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Project Structure & Configuration

Understand .NET Core project structure, configuration system, and best practices

Content by: Dipen Dalvadi

.Net Developer

Connect

Typical .NET Core Project Structure

Code Example

MyApp/
├── Program.cs                 # Application entry point
├── MyApp.csproj              # Project file
├── appsettings.json          # Configuration file
├── appsettings.Development.json
├── Properties/
│   └── launchSettings.json   # Launch configuration
├── Controllers/              # MVC Controllers (if applicable)
├── Models/                   # Data models
├── Services/                 # Business logic services
├── wwwroot/                  # Static files (web apps)
└── bin/                      # Build output
    └── Debug/
        └── net6.0/

Swipe to see more code

MyApp/
├── Program.cs                 # Application entry point
├── MyApp.csproj              # Project file
├── appsettings.json          # Configuration file
├── appsettings.Development.json
├── Properties/
│   └── launchSettings.json   # Launch configuration
├── Controllers/              # MVC Controllers (if applicable)
├── Models/                   # Data models
├── Services/                 # Business logic services
├── wwwroot/                  # Static files (web apps)
└── bin/                      # Build output
    └── Debug/
        └── net6.0/

Scroll

Configuration System

Code Example

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();
        host.Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((context, config) =>
            {
                config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
                config.AddJsonFile($"appsettings.{context.HostingEnvironment.EnvironmentName}.json", 
                    optional: true, reloadOnChange: true);
                config.AddEnvironmentVariables();
                config.AddCommandLine(args);
            })
            .ConfigureServices((context, services) =>
            {
                // Register services here
                services.Configure<MyOptions>(context.Configuration.GetSection("MyOptions"));
            });
}

Swipe to see more code

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

public class Program
{
    public static void Main(string[] args)
    {
        var host = CreateHostBuilder(args).Build();
        host.Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((context, config) =>
            {
                config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
                config.AddJsonFile($"appsettings.{context.HostingEnvironment.EnvironmentName}.json", 
                    optional: true, reloadOnChange: true);
                config.AddEnvironmentVariables();
                config.AddCommandLine(args);
            })
            .ConfigureServices((context, services) =>
            {
                // Register services here
                services.Configure<MyOptions>(context.Configuration.GetSection("MyOptions"));
            });
}

Scroll

Configuration Best Practices

•Use appsettings.json for default configuration
•Use environment-specific files (appsettings.Development.json)
•Store sensitive data in User Secrets or Azure Key Vault
•Use strongly-typed configuration with IOptions<T>
•Validate configuration at startup
•Use configuration providers in order of precedence

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Dependency Injection Basics

Learn .NET Core's built-in dependency injection container and how to use it effectively

Content by: Sunny Radadiya

.Net Developer

Connect

What is Dependency Injection?

Dependency Injection (DI) is a design pattern that implements Inversion of Control (IoC) for resolving dependencies. .NET Core has a built-in DI container that makes it easy to manage dependencies throughout your application.

Service Lifetimes

Code Example

// Transient: New instance every time
services.AddTransient<IMyService, MyService>();

// Scoped: One instance per request (web apps)
services.AddScoped<IMyService, MyService>();

// Singleton: One instance for the entire application
services.AddSingleton<IMyService, MyService>();

// Example implementation
public interface IEmailService
{
    Task SendEmailAsync(string to, string subject, string body);
}

public class EmailService : IEmailService
{
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // Email sending logic
        await Task.CompletedTask;
    }
}

// Registration
services.AddScoped<IEmailService, EmailService>();

Swipe to see more code

// Transient: New instance every time
services.AddTransient<IMyService, MyService>();

// Scoped: One instance per request (web apps)
services.AddScoped<IMyService, MyService>();

// Singleton: One instance for the entire application
services.AddSingleton<IMyService, MyService>();

// Example implementation
public interface IEmailService
{
    Task SendEmailAsync(string to, string subject, string body);
}

public class EmailService : IEmailService
{
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // Email sending logic
        await Task.CompletedTask;
    }
}

// Registration
services.AddScoped<IEmailService, EmailService>();

Scroll

Advanced DI Patterns

Code Example

// Factory pattern
services.AddTransient<Func<string, ILogger>>(provider => key =>
    provider.GetService<ILoggerFactory>().CreateLogger(key));

// Options pattern
services.Configure<DatabaseOptions>(configuration.GetSection("Database"));

// Multiple implementations
services.AddTransient<INotificationService, EmailNotificationService>();
services.AddTransient<INotificationService, SmsNotificationService>();

// Decorator pattern
services.AddTransient<INotificationService, LoggingNotificationService>();
services.Decorate<INotificationService, CachingNotificationService>();

Swipe to see more code

// Factory pattern
services.AddTransient<Func<string, ILogger>>(provider => key =>
    provider.GetService<ILoggerFactory>().CreateLogger(key));

// Options pattern
services.Configure<DatabaseOptions>(configuration.GetSection("Database"));

// Multiple implementations
services.AddTransient<INotificationService, EmailNotificationService>();
services.AddTransient<INotificationService, SmsNotificationService>();

// Decorator pattern
services.AddTransient<INotificationService, LoggingNotificationService>();
services.Decorate<INotificationService, CachingNotificationService>();

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Configuration & Settings

Master .NET Core's configuration system and settings management

Content by: Akash Vadher

.Net Developer

Connect

Configuration Sources

`.NET Core supports multiple configuration sources that are loaded in a specific order, with later sources overriding earlier ones.

Configuration Providers

Code Example

// JSON files
config.AddJsonFile("appsettings.json");
config.AddJsonFile("appsettings.Development.json", optional: true);

// Environment variables
config.AddEnvironmentVariables();

// Command line arguments
config.AddCommandLine(args);

// User secrets (development only)
config.AddUserSecrets<Program>();

// Azure Key Vault
config.AddAzureKeyVault(vaultUrl, clientId, clientSecret);

// Custom provider
config.Add(new CustomConfigurationProvider());

Swipe to see more code

// JSON files
config.AddJsonFile("appsettings.json");
config.AddJsonFile("appsettings.Development.json", optional: true);

// Environment variables
config.AddEnvironmentVariables();

// Command line arguments
config.AddCommandLine(args);

// User secrets (development only)
config.AddUserSecrets<Program>();

// Azure Key Vault
config.AddAzureKeyVault(vaultUrl, clientId, clientSecret);

// Custom provider
config.Add(new CustomConfigurationProvider());

Scroll

Strongly-Typed Configuration

Code Example

// Define configuration class
public class DatabaseOptions
{
    public const string SectionName = "Database";
    
    public string ConnectionString { get; set; }
    public int CommandTimeout { get; set; } = 30;
    public bool EnableRetryOnFailure { get; set; } = true;
}

// Register in DI container
services.Configure<DatabaseOptions>(
    configuration.GetSection(DatabaseOptions.SectionName));

// Use in your service
public class DataService
{
    private readonly DatabaseOptions _options;
    
    public DataService(IOptions<DatabaseOptions> options)
    {
        _options = options.Value;
    }
    
    public void Connect()
    {
        // Use _options.ConnectionString
    }
}

Swipe to see more code

// Define configuration class
public class DatabaseOptions
{
    public const string SectionName = "Database";
    
    public string ConnectionString { get; set; }
    public int CommandTimeout { get; set; } = 30;
    public bool EnableRetryOnFailure { get; set; } = true;
}

// Register in DI container
services.Configure<DatabaseOptions>(
    configuration.GetSection(DatabaseOptions.SectionName));

// Use in your service
public class DataService
{
    private readonly DatabaseOptions _options;
    
    public DataService(IOptions<DatabaseOptions> options)
    {
        _options = options.Value;
    }
    
    public void Connect()
    {
        // Use _options.ConnectionString
    }
}

Scroll

🎯 Practice Exercise

Test your understanding of this topic:

I understand the basic concepts covered in this topicI can apply the concepts in practical scenariosI'm ready to move to the next topic

Next Module

Module 2: Advanced C# & .NET Core Features

Ready for the Next Module?

Continue your learning journey and master the next set of concepts.

Continue to Module 2

Module 1: .NET Core Fundamentals & Setup

.NET Core Fundamentals & Setup

Select Topics Overview

.NET Core Introduction & History

Cross-Platform Development

CLI Tools & Commands

Project Structure & Configuration

Dependency Injection Basics

Configuration & Settings

.NET Core Introduction & History

Cross-Platform Development

CLI Tools & Commands

Project Structure & Configuration

Dependency Injection Basics

Configuration & Settings

.NET Core Introduction & History

What is .NET Core?

Key Features of .NET Core

.NET Core vs .NET Framework

🎯 Practice Exercise

Cross-Platform Development

Platform-Specific Considerations

Cross-Platform Best Practices

Platform Detection Example

🎯 Practice Exercise

CLI Tools & Commands

Essential .NET CLI Commands

Project Management Commands

Solution Management

🎯 Practice Exercise

Project Structure & Configuration

Typical .NET Core Project Structure

Configuration System

Configuration Best Practices

🎯 Practice Exercise

Dependency Injection Basics

What is Dependency Injection?

Service Lifetimes

Advanced DI Patterns

🎯 Practice Exercise

Configuration & Settings

Configuration Sources

Configuration Providers

Strongly-Typed Configuration

🎯 Practice Exercise

Module 2: Advanced C# & .NET Core Features

Ready for the Next Module?