What Is a .CS File?

C# (.cs)

Overview

C# (pronounced "C-sharp") is a modern, object-oriented programming language developed by Microsoft as part of the .NET framework. Created by Anders Hejlsberg in 2000, C# combines the power and flexibility of C++ with the simplicity of Visual Basic. It's designed for building a wide variety of applications that run on the .NET ecosystem, from desktop applications to web services, mobile apps, and cloud solutions.

Technical Details

• File Extension: .cs
• MIME Type: text/x-csharp
• Category: Programming Language
• First Appeared: 2000
• Paradigm: Object-oriented, functional, imperative, generic
• Platform: .NET Framework, .NET Core, .NET 5/6/7/8+

Key Features

Modern Object-Oriented Design

• Strong type safety with static typing
• Automatic garbage collection
• Properties, events, and indexers
• Operator overloading and extension methods

Advanced Language Features

• LINQ (Language Integrated Query)
• Async/await pattern for asynchronous programming
• Generics with constraints
• Lambda expressions and delegates

Cross-Platform Development

• .NET Core and .NET 5+ run on Windows, macOS, Linux
• Unified platform for various application types
• Docker support and cloud-native development
• Performance optimizations and AOT compilation

Syntax Examples

Basic C# Constructs

using System;

// Namespace declaration
namespace MyApplication
{
    // Class definition
    public class Program
    {
        // Main method - entry point
        public static void Main(string[] args)
        {
            // Variables
            string name = "C#";
            int version = 12;
            double rating = 9.5;
            bool isAwesome = true;
            
            // String interpolation
            Console.WriteLine($"Welcome to {name} {version}!");
            Console.WriteLine($"Rating: {rating}/10, Awesome: {isAwesome}");
            
            // Method calls
            GreetUser("Alice");
            int sum = AddNumbers(5, 3);
            Console.WriteLine($"Sum: {sum}");
        }
        
        // Static method
        public static void GreetUser(string userName)
        {
            Console.WriteLine($"Hello, {userName}!");
        }
        
        // Method with return value
        public static int AddNumbers(int a, int b)
        {
            return a + b;
        }
    }
}

Object-Oriented Programming

// Base class
public abstract class Animal
{
    protected string name;
    protected int age;
    
    public Animal(string name, int age)
    {
        this.name = name;
        this.age = age;
    }
    
    // Properties
    public string Name 
    { 
        get { return name; } 
        set { name = value; } 
    }
    
    // Auto-implemented property
    public int Age { get; set; }
    
    // Abstract method
    public abstract void MakeSound();
    
    // Virtual method
    public virtual void Sleep()
    {
        Console.WriteLine($"{name} is sleeping.");
    }
}

// Derived class
public class Dog : Animal
{
    public string Breed { get; set; }
    
    public Dog(string name, int age, string breed) : base(name, age)
    {
        Breed = breed;
    }
    
    // Override abstract method
    public override void MakeSound()
    {
        Console.WriteLine($"{name} barks: Woof woof!");
    }
    
    // Override virtual method
    public override void Sleep()
    {
        Console.WriteLine($"{name} the {Breed} is sleeping on the couch.");
    }
    
    // Additional method
    public void WagTail()
    {
        Console.WriteLine($"{name} is wagging tail happily!");
    }
}

// Interface
public interface IFlyable
{
    void Fly();
    int MaxAltitude { get; }
}

// Class implementing interface
public class Bird : Animal, IFlyable
{
    public int MaxAltitude { get; private set; }
    
    public Bird(string name, int age, int maxAltitude) : base(name, age)
    {
        MaxAltitude = maxAltitude;
    }
    
    public override void MakeSound()
    {
        Console.WriteLine($"{name} chirps: Tweet tweet!");
    }
    
    public void Fly()
    {
        Console.WriteLine($"{name} is flying up to {MaxAltitude} feet!");
    }
}

Generics and Collections

using System;
using System.Collections.Generic;
using System.Linq;

// Generic class
public class Repository<T> where T : class
{
    private List<T> items = new List<T>();
    
    public void Add(T item)
    {
        items.Add(item);
    }
    
    public void Remove(T item)
    {
        items.Remove(item);
    }
    
    public T FindById(int id) where T : IIdentifiable
    {
        return items.FirstOrDefault(item => item.Id == id);
    }
    
    public IEnumerable<T> GetAll()
    {
        return items.AsReadOnly();
    }
    
    public int Count => items.Count;
}

// Interface for identifiable objects
public interface IIdentifiable
{
    int Id { get; }
}

// Example model
public class User : IIdentifiable
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public DateTime CreatedAt { get; set; }
    
    public User(int id, string name, string email)
    {
        Id = id;
        Name = name;
        Email = email;
        CreatedAt = DateTime.Now;
    }
}

// Usage example
public class Example
{
    public static void DemonstrateGenerics()
    {
        var userRepo = new Repository<User>();
        
        userRepo.Add(new User(1, "Alice", "alice@example.com"));
        userRepo.Add(new User(2, "Bob", "bob@example.com"));
        
        var user = userRepo.FindById(1);
        Console.WriteLine($"Found user: {user?.Name}");
        
        Console.WriteLine($"Total users: {userRepo.Count}");
    }
}

LINQ and Functional Programming

using System;
using System.Collections.Generic;
using System.Linq;

public class LinqExample
{
    public static void DemonstrateLINQ()
    {
        var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        var names = new List<string> { "Alice", "Bob", "Charlie", "David", "Eve" };
        
        // Query syntax
        var evenNumbers = from n in numbers
                         where n % 2 == 0
                         select n;
        
        // Method syntax
        var squaredEvens = numbers
            .Where(n => n % 2 == 0)
            .Select(n => n * n)
            .ToList();
        
        // Complex queries
        var longNames = names
            .Where(name => name.Length > 4)
            .OrderBy(name => name)
            .ToArray();
        
        // Aggregations
        var sum = numbers.Sum();
        var average = numbers.Average();
        var max = numbers.Max();
        var count = numbers.Count(n => n > 5);
        
        // Group by
        var groupedByLength = names
            .GroupBy(name => name.Length)
            .Select(g => new { Length = g.Key, Names = g.ToList() });
        
        Console.WriteLine($"Even numbers: {string.Join(", ", evenNumbers)}");
        Console.WriteLine($"Squared evens: {string.Join(", ", squaredEvens)}");
        Console.WriteLine($"Long names: {string.Join(", ", longNames)}");
        Console.WriteLine($"Sum: {sum}, Average: {average:F2}, Max: {max}, Count > 5: {count}");
    }
}

// Custom extension method
public static class Extensions
{
    public static IEnumerable<T> WhereNot<T>(this IEnumerable<T> source, Func<T, bool> predicate)
    {
        return source.Where(item => !predicate(item));
    }
    
    public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
    {
        foreach (var item in source)
        {
            action(item);
        }
    }
}

Asynchronous Programming

using System;
using System.Net.Http;
using System.Threading.Tasks;
using System.Collections.Generic;

public class AsyncExample
{
    private static readonly HttpClient httpClient = new HttpClient();
    
    // Async method with Task return type
    public static async Task<string> FetchDataAsync(string url)
    {
        try
        {
            HttpResponseMessage response = await httpClient.GetAsync(url);
            response.EnsureSuccessStatusCode();
            string content = await response.Content.ReadAsStringAsync();
            return content;
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"Request error: {ex.Message}");
            return null;
        }
    }
    
    // Async method with void return (for event handlers)
    public static async void ProcessDataAsync()
    {
        string data = await FetchDataAsync("https://api.example.com/data");
        if (data != null)
        {
            Console.WriteLine($"Received data: {data.Substring(0, Math.Min(100, data.Length))}...");
        }
    }
    
    // Parallel async operations
    public static async Task<List<string>> FetchMultipleUrlsAsync(List<string> urls)
    {
        var tasks = urls.Select(url => FetchDataAsync(url));
        string[] results = await Task.WhenAll(tasks);
        return results.Where(result => result != null).ToList();
    }
    
    // Async enumerable (C# 8.0+)
    public static async IAsyncEnumerable<int> GenerateNumbersAsync()
    {
        for (int i = 0; i < 10; i++)
        {
            await Task.Delay(100); // Simulate async work
            yield return i;
        }
    }
    
    // Using async enumerable
    public static async Task ConsumeAsyncEnumerableAsync()
    {
        await foreach (int number in GenerateNumbersAsync())
        {
            Console.WriteLine($"Generated: {number}");
        }
    }
}

Modern C# Features

Pattern Matching and Switch Expressions

// Pattern matching (C# 7.0+)
public static string DescribeObject(object obj)
{
    return obj switch
    {
        int i when i > 0 => $"Positive integer: {i}",
        int i when i < 0 => $"Negative integer: {i}",
        int => "Zero",
        string s when s.Length > 10 => $"Long string: {s[..10]}...",
        string s => $"Short string: {s}",
        DateTime dt => $"Date: {dt:yyyy-MM-dd}",
        null => "Null value",
        _ => "Unknown type"
    };
}

// Records (C# 9.0+)
public record Person(string FirstName, string LastName, int Age)
{
    public string FullName => $"{FirstName} {LastName}";
}

// With expressions for immutable updates
public static void DemonstrateRecords()
{
    var person = new Person("John", "Doe", 30);
    var olderPerson = person with { Age = 31 };
    
    Console.WriteLine($"Original: {person}");
    Console.WriteLine($"Updated: {olderPerson}");
}

// Nullable reference types (C# 8.0+)
#nullable enable
public class NullableExample
{
    public string Name { get; set; } = string.Empty; // Non-nullable
    public string? Description { get; set; }         // Nullable
    
    public void ProcessName(string? input)
    {
        if (input is not null)
        {
            Name = input.ToUpper();
        }
    }
}

File-Scoped Namespaces and Global Usings

// File-scoped namespace (C# 10.0+)
namespace MyApp.Services;

// Global usings (in GlobalUsings.cs)
global using System;
global using System.Collections.Generic;
global using System.Linq;
global using System.Threading.Tasks;

// Top-level programs (C# 9.0+)
using System;

Console.WriteLine("Hello, World!");
await ProcessDataAsync();

static async Task ProcessDataAsync()
{
    // Implementation here
}

Web Development with ASP.NET Core

Web API Controller

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserService _userService;
    
    public UsersController(IUserService userService)
    {
        _userService = userService;
    }
    
    [HttpGet]
    public async Task<ActionResult<IEnumerable<User>>> GetUsers()
    {
        var users = await _userService.GetAllUsersAsync();
        return Ok(users);
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<User>> GetUser(int id)
    {
        var user = await _userService.GetUserByIdAsync(id);
        if (user == null)
        {
            return NotFound();
        }
        return Ok(user);
    }
    
    [HttpPost]
    public async Task<ActionResult<User>> CreateUser(CreateUserRequest request)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }
        
        var user = await _userService.CreateUserAsync(request);
        return CreatedAtAction(nameof(GetUser), new { id = user.Id }, user);
    }
    
    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateUser(int id, UpdateUserRequest request)
    {
        var result = await _userService.UpdateUserAsync(id, request);
        if (!result)
        {
            return NotFound();
        }
        return NoContent();
    }
    
    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteUser(int id)
    {
        var result = await _userService.DeleteUserAsync(id);
        if (!result)
        {
            return NotFound();
        }
        return NoContent();
    }
}

Dependency Injection and Services

// Service interface
public interface IUserService
{
    Task<IEnumerable<User>> GetAllUsersAsync();
    Task<User?> GetUserByIdAsync(int id);
    Task<User> CreateUserAsync(CreateUserRequest request);
    Task<bool> UpdateUserAsync(int id, UpdateUserRequest request);
    Task<bool> DeleteUserAsync(int id);
}

// Service implementation
public class UserService : IUserService
{
    private readonly IUserRepository _repository;
    private readonly ILogger<UserService> _logger;
    
    public UserService(IUserRepository repository, ILogger<UserService> logger)
    {
        _repository = repository;
        _logger = logger;
    }
    
    public async Task<IEnumerable<User>> GetAllUsersAsync()
    {
        _logger.LogInformation("Fetching all users");
        return await _repository.GetAllAsync();
    }
    
    public async Task<User?> GetUserByIdAsync(int id)
    {
        _logger.LogInformation("Fetching user with ID: {UserId}", id);
        return await _repository.GetByIdAsync(id);
    }
    
    // ... other methods
}

// Startup configuration
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
        services.AddScoped<IUserService, UserService>();
        services.AddScoped<IUserRepository, UserRepository>();
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(connectionString));
    }
    
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        
        app.UseRouting();
        app.UseAuthentication();
        app.UseAuthorization();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

Entity Framework Core

DbContext and Models

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<User> Users { get; set; }
    public DbSet<Post> Posts { get; set; }
    public DbSet<Comment> Comments { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // User configuration
        modelBuilder.Entity<User>(entity =>
        {
            entity.HasKey(u => u.Id);
            entity.Property(u => u.Email).IsRequired().HasMaxLength(255);
            entity.HasIndex(u => u.Email).IsUnique();
            entity.Property(u => u.CreatedAt).HasDefaultValueSql("GETUTCDATE()");
        });
        
        // Post configuration
        modelBuilder.Entity<Post>(entity =>
        {
            entity.HasKey(p => p.Id);
            entity.Property(p => p.Title).IsRequired().HasMaxLength(200);
            entity.Property(p => p.Content).IsRequired();
            entity.HasOne(p => p.Author)
                  .WithMany(u => u.Posts)
                  .HasForeignKey(p => p.AuthorId)
                  .OnDelete(DeleteBehavior.Cascade);
        });
        
        // Comment configuration
        modelBuilder.Entity<Comment>(entity =>
        {
            entity.HasKey(c => c.Id);
            entity.Property(c => c.Content).IsRequired().HasMaxLength(1000);
            entity.HasOne(c => c.Post)
                  .WithMany(p => p.Comments)
                  .HasForeignKey(c => c.PostId);
            entity.HasOne(c => c.Author)
                  .WithMany()
                  .HasForeignKey(c => c.AuthorId);
        });
    }
}

// Models
public class User
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public string Email { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    public List<Post> Posts { get; set; } = new();
}

public class Post
{
    public int Id { get; set; }
    public string Title { get; set; } = string.Empty;
    public string Content { get; set; } = string.Empty;
    public DateTime CreatedAt { get; set; }
    public int AuthorId { get; set; }
    public User Author { get; set; } = null!;
    public List<Comment> Comments { get; set; } = new();
}

Testing Framework

Unit Testing with xUnit

using Xunit;
using Moq;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

public class UserServiceTests
{
    private readonly Mock<IUserRepository> _mockRepository;
    private readonly Mock<ILogger<UserService>> _mockLogger;
    private readonly UserService _userService;
    
    public UserServiceTests()
    {
        _mockRepository = new Mock<IUserRepository>();
        _mockLogger = new Mock<ILogger<UserService>>();
        _userService = new UserService(_mockRepository.Object, _mockLogger.Object);
    }
    
    [Fact]
    public async Task GetUserByIdAsync_UserExists_ReturnsUser()
    {
        // Arrange
        var userId = 1;
        var expectedUser = new User { Id = userId, Name = "John Doe", Email = "john@example.com" };
        _mockRepository.Setup(r => r.GetByIdAsync(userId))
                      .ReturnsAsync(expectedUser);
        
        // Act
        var result = await _userService.GetUserByIdAsync(userId);
        
        // Assert
        Assert.NotNull(result);
        Assert.Equal(expectedUser.Id, result.Id);
        Assert.Equal(expectedUser.Name, result.Name);
        Assert.Equal(expectedUser.Email, result.Email);
    }
    
    [Fact]
    public async Task GetUserByIdAsync_UserNotExists_ReturnsNull()
    {
        // Arrange
        var userId = 999;
        _mockRepository.Setup(r => r.GetByIdAsync(userId))
                      .ReturnsAsync((User?)null);
        
        // Act
        var result = await _userService.GetUserByIdAsync(userId);
        
        // Assert
        Assert.Null(result);
    }
    
    [Theory]
    [InlineData("")]
    [InlineData(" ")]
    [InlineData(null)]
    public async Task CreateUserAsync_InvalidName_ThrowsArgumentException(string invalidName)
    {
        // Arrange
        var request = new CreateUserRequest { Name = invalidName, Email = "test@example.com" };
        
        // Act & Assert
        await Assert.ThrowsAsync<ArgumentException>(() => _userService.CreateUserAsync(request));
    }
}

Development Tools

Project Configuration

<!-- .csproj file -->
<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net8.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.0" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
    <PackageReference Include="Serilog.AspNetCore" Version="7.0.0" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\MyApp.Core\MyApp.Core.csproj" />
    <ProjectReference Include="..\MyApp.Infrastructure\MyApp.Infrastructure.csproj" />
  </ItemGroup>

</Project>

Development Environment

• Visual Studio: Full-featured IDE
• Visual Studio Code: Lightweight editor with C# extension
• JetBrains Rider: Cross-platform .NET IDE
• Visual Studio for Mac: macOS development

Package Management

# dotnet CLI commands
dotnet new webapi -n MyApiProject
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet restore
dotnet build
dotnet run
dotnet test
dotnet publish -c Release

Common Use Cases

Enterprise Applications

• Line-of-business applications
• Enterprise resource planning (ERP)
• Customer relationship management (CRM)
• Financial and accounting systems

Web Development

• ASP.NET Core web applications
• RESTful APIs and microservices
• Blazor single-page applications
• Progressive web applications

Desktop Applications

• WPF (Windows Presentation Foundation)
• WinUI 3 applications
• .NET MAUI cross-platform apps
• Windows Forms (legacy)

Cloud and DevOps

• Azure Functions serverless computing
• Docker containerized applications
• Kubernetes orchestration
• CI/CD pipelines with Azure DevOps

Notable Applications

• Stack Overflow: Q&A platform
• Microsoft Office: Various components
• Unity Game Engine: Scripting language
• Visual Studio: IDE itself
• Azure: Cloud platform services

Learning Resources

• "C# 12 and .NET 8 – Modern Cross-Platform Development" by Mark J. Price
• "Pro C# 10 with .NET 6" by Andrew Troelsen
• Microsoft's official C# documentation
• Pluralsight and Udemy courses
• C# programming communities and forums

C# continues to evolve as a powerful, versatile language that balances performance, productivity, and modern language features, making it an excellent choice for a wide range of applications from web services to desktop applications and cloud solutions.