C# Tutorial

C# String

C# Array

C# Flow Control

C# Class and Object

C# Inheritance

C# Interface

C# Collection

C# Generic

C# File I/O

C# Delegate and Event

C# Exception

C# Process and Thread

C# ADO.NET Database Operations

C# Nested Classes

In C#, you can define a class within another class, which is known as a nested class. Nested classes can be used to encapsulate functionality that is only relevant to the containing class, or to group related classes together. In this tutorial, we'll cover the following topics related to nested classes in C#:

Defining a nested class
Accessing a nested class
Access modifiers for nested classes
When to use nested classes

Let's begin!

Defining a nested class

To define a nested class, simply declare a class inside another class:

public class OuterClass
{
    public class NestedClass
    {
        public void NestedMethod()
        {
            Console.WriteLine("Hello from the nested class!");
        }
    }
}

In this example, NestedClass is a nested class within OuterClass.

Accessing a nested class

To access a nested class, you need to create an instance of the outer class and then create an instance of the nested class using the outer class instance:

public static void Main(string[] args)
{
    OuterClass outerObject = new OuterClass();
    OuterClass.NestedClass nestedObject = new OuterClass.NestedClass();
    
    nestedObject.NestedMethod(); // Output: "Hello from the nested class!"
}

Access modifiers for nested classes

Nested classes can have access modifiers, just like other class members. By default, a nested class has private access, which means it can only be accessed within the containing class. You can also use the public, protected, and internal access modifiers:

public: The nested class can be accessed from any code.
protected: The nested class can be accessed only within the containing class and its derived classes.
internal: The nested class can be accessed only within the same assembly.

public class OuterClass
{
    private class PrivateNestedClass { /*...*/ }
    protected class ProtectedNestedClass { /*...*/ }
    internal class InternalNestedClass { /*...*/ }
    public class PublicNestedClass { /*...*/ }
}

When to use nested classes

Nested classes can be useful in the following scenarios:

When a class is only relevant to the containing class, and you want to keep them together.
When you want to encapsulate functionality that is only used by the containing class.
When you want to group related classes together to improve organization and readability.

However, avoid overusing nested classes, as they can make the code more complex and harder to understand. If a nested class is too large or has too many responsibilities, consider moving it to a separate file.

That's it! You now have a basic understanding of how to use nested classes in C#. Nested classes provide a way to group related classes together, encapsulate functionality, and improve code organization.

How to define nested classes in C#
Nested classes are defined within the scope of another class:
```
class OuterClass
{
    class NestedClass
    {
        // Nested class members
    }
}
```

Access modifiers for nested classes in C#

Nested classes can have the same access modifiers as any other class:

class OuterClass
{
    private class PrivateNestedClass
    {
        // Private nested class members
    }
}

Static nested classes in C#

Static nested classes do not require an instance of the outer class:

class OuterClass
{
    public static class StaticNestedClass
    {
        // Static nested class members
    }
}

Using nested classes for encapsulation in C#

Nested classes can access private members of the outer class, enhancing encapsulation:

class OuterClass
{
    private int privateField;

    class NestedClass
    {
        public void AccessOuterClass(OuterClass outer)
        {
            outer.privateField = 42;
        }
    }
}

C# nested class examples

class OuterClass
{
    private int outerField;

    public class NestedClass
    {
        public void AccessOuterField(OuterClass outer)
        {
            outer.outerField = 10;
        }
    }
}

Inheritance with nested classes in C#

Nested classes can inherit from other classes:

class BaseClass
{
    // Base class members
}

class OuterClass
{
    class NestedClass : BaseClass
    {
        // Derived class members
    }
}

Private nested classes in C#

Nested classes are often private to the outer class to restrict access:

class OuterClass
{
    private class PrivateNestedClass
    {
        // Private nested class members
    }
}

Nested classes and access to outer class members in C#

Nested classes can access private members of the outer class:

class OuterClass
{
    private int privateField;

    class NestedClass
    {
        public void AccessOuterField(OuterClass outer)
        {
            outer.privateField = 42;
        }
    }
}

C# nested classes and namespace organization

Nested classes can help organize code within a namespace:

namespace MyNamespace
{
    class OuterClass
    {
        class NestedClass
        {
            // Nested class members
        }
    }
}

Inner classes and encapsulation in C#
Inner classes, or nested classes, contribute to encapsulation by having access to the private members of the outer class.

C# nested classes and readability

Nested classes can improve code readability by grouping related functionality:

class Report
{
    // Outer class members

    class Header
    {
        // Nested class for header
    }

    class Body
    {
        // Nested class for body
    }

    class Footer
    {
        // Nested class for footer
    }
}