Introduction
Classes are the foundation of Object-Oriented Programming (OOP) in C#. Every application you build—whether it's a console program, a desktop application, a web API, or a cloud service—relies on classes to structure data, behavior, and functionality.
Understanding what a class is, how it works, and the different types of classes available in C# is essential for writing clean, maintainable, and scalable applications. This guide covers all aspects of classes in C#, from basic definitions to advanced class types like abstract classes, records, generics, partial classes, and more.
This article is written in simple, easy-to-understand language while offering depth suitable for interviews, real-world development, and architectural decision-making.
What Is a Class in C#?
A class in C# is a blueprint or template for creating objects. It defines:
Fields (data)
Properties
Methods (behavior)
Constructors
Events
Indexers
Think of a class as a design, and objects as real-world things created from that design.
Example of a Simple Class
public class Employee
{
public int Id;
public string Name;
public void Work()
{
Console.WriteLine($"{Name} is working.");
}
}
A class does not occupy memory by itself. Memory is allocated only when an object is created.
What Is an Object?
An object is an instance of a class.
It represents actual data stored in memory.
Example
Employee emp = new Employee();
emp.Id = 1;
emp.Name = "Ajay";
emp.Work();
Here
Structure of a Class in C#
A typical class contains:
public class Student
{
private int rollNo;
private string name;
public Student(int rollNo, string name)
{
this.rollNo = rollNo;
this.name = name;
}
public void Display()
{
Console.WriteLine($"{rollNo} - {name}");
}
public string Name { get; set; }
}
Types of Classes in C#
C# supports a wide range of class types that provide flexibility for various programming needs. Below is a detailed explanation of each class.
1. Concrete Class
A concrete class is the most commonly used class in C#.
A concrete class provides full implementations for all its methods and members.
Objects can be created directly using the new keyword.
It is typically used to represent real-world entities such as Customer, Order, or Product.
Concrete classes can be inherited, making them the base of object-oriented design.
Example
public class Car
{
public void Drive()
{
Console.WriteLine("Car is moving...");
}
}
2. Partial Class
A partial class allows splitting a single class definition into multiple files.
Useful in large projects where separating responsibilities improves readability and maintainability.
Commonly used in auto-generated code (e.g., WinForms, Entity Framework).
Different team members can work on the same class across multiple files.
The compiler merges all parts into a single class at compile-time.
Example
File 1
public partial class Employee
{
public int Id;
}
File 2
public partial class Employee
{
public void Display() => Console.WriteLine(Id);
}
3. Static Class
A static class is used when the class should not (and cannot) be instantiated.
It contains only static members, meaning shared across the application.
It is loaded once in memory, improving performance for utility operations.
Static classes cannot be inherited or instantiated.
Commonly used for helper methods and global utilities (e.g., encryption, math operations).
Example
public static class MathHelper
{
public static int Add(int a, int b) => a + b;
}
4. Sealed Class
A sealed class restricts other classes from inheriting it.
Prevents unwanted extension of class behavior to maintain system integrity.
It can increase runtime performance because sealed methods cannot be overridden.
Useful when designing classes that should remain unchanged (e.g., security logic).
Helps avoid accidental misuse of inheritance.
Example
public sealed class PaymentService
{
public void Pay() { }
}
5. Abstract Class
An abstract class may contain abstract methods (no implementation) and non-abstract methods (with implementation).
Cannot be instantiated directly; serves as a base class.
Forces derived classes to implement abstract members.
Supports fields, methods, properties, and constructors.
Useful for shared base behavior across multiple child classes.
Example
public abstract class Shape
{
public abstract double Area();
}
6. Nested Class
A class defined inside another class.
Helps group supporting classes inside a main class for better organization.
Can access private members of the outer class.
Reduces namespace clutter—useful for helper or internal-only classes.
Improves encapsulation for related logic.
Example
public class Outer
{
public class Inner
{
public void Show() => Console.WriteLine("Inner class");
}
}
7. Anonymous Class
Anonymous classes are created without explicitly defining their name.
Useful for storing temporary, read-only data without creating a named class.
Often used in LINQ queries for shaping or projecting data.
Automatically generated by the compiler.
Properties are created automatically and are immutable.
Example
var emp = new { Id = 1, Name = "Ajay" };
8. POCO Class (Plain Old CLR Object)
A simple class without inheritance or heavy framework dependencies.
Contains only properties and minimal logic, making it lightweight and clean.
Used widely with Entity Framework, Web APIs, and clean architectures.
Supports easy serialization and model binding.
Promotes separation of concerns.
Example
public class Customer
{
public int Id { get; set; }
public string Name { get; set; }
}
9. Record Class
A modern C# feature for immutable data modeling.
Records use value-based equality (compares values, not references).
Ideal for DTOs, API models, and configurations.
Support non-destructive mutation using the with expression.
Easy shorthand syntax for concise data models.
Example
public record Product(int Id, string Name, double Price);
10. Generic Class
A class with type parameters allowing type flexibility.
Enhances reusability by allowing classes to work with any data type.
Eliminates boxing/unboxing, improving performance.
Used extensively in .NET collections like List and Dictionary<TKey, TValue>.
Enables type-safe operations without repeated class definitions.
Example
public class Box<T>
{
public T Value { get; set; }
}
Real-World Scenario Using Multiple Class Types
Consider a payment processing module:
An abstract class defines the base behavior (Payment).
Concrete classes implement methods (UpiPayment, CardPayment).
A static class provides utility logging (PaymentLogger).
A POCO class represents the user request.
A nested class exists for packaging response status.
A record class stores immutable transaction results.
This demonstrates how different class types work together harmoniously in real projects.