OOP (object oriented programming)What is the class?What do you mean by object?What are the differences between class and object?Can you create an object without using new operator in C#?What is constructor and how many constructors can have one class?Differences between constructor and method of the class? What is default constructor?What is parameterized Constructor in C#?What is private constructor: In what instances you will declare a constructor to be private?What is static constructor, Is it possible to have a static constructor in class. If yes why we need to have a static constructor?Does C# provide copy constructor for an object? How do you call the multiple constructors of a class with single object creation?What is constructor chaining in C#?Can a constructor be called directly from a method?What is constructor overloading and how it’s different than method overloading?What is the difference between constructor overloading and method overloading?Is it possible to overload copy constructor in C#?Can we overload static constructors in C#?Can we overload private constructors in C#?Can we give return type of the constructor in C#?What is the destructor and when it’s called?Is it possible to call constructor and destructor explicitly?What is the Structure and why we need it although we have a class?What are the similarities between Class and Structure?What is the difference between Class and Structure?What is copy structure?What is nested structure?Is it always necessary to create an object of the class?How many different ways to create an object of the class?What are the pros and cons of creating object by new() keyword?What are the pros and cons of delegate object creation to DI container?What are the pros and cons of creating an object by reflection?What are the pros and cons of getting an object from an object pool?What are the pros and cons of creating an object by deserialization?Is it possible to create an object without a class in C#?What is constant?What is static modifier? What are the Static fields and methodsWhat is Static ReadOnly?What are the limitations of static?What is readonly? What’s the difference between constant and read-only?What is this keyword?What is base keyword?What is the difference between this and base keyword?Can “this” keyword be used within static method?What are the accessors?What is the static class? Why we need of static class?If someone wants to create static class then what are the rules for the static class?What are the limitations of using static keyword?What are finalizers in c#?How to create N number of instances of C# class?What are the Nested Classes and why we use them?What are the basic four pillars of OOP?What is the Inheritance and why we need of inheritance?How do you inherit a class into other class in C#?What is the concept of base and derive class?What are the different types of inheritance?We have two classes’ base class and child class. A is the base class and B is the child class, If we create an instance of child class then which class’s constructor called first?Does a derived class can inherit the constructors of its base class?What should we do that if we create an object of child class then the parameterized constructor of base class must be invoked?As we know that base constructor invoked first when we create instance of child class but if we create an instance of child class by parameterized constructor and base class has both default and parameterized constructor then which constructor of the base will be invoked?Can you assign an object of derived class to the variable of base class and if both have the same method name then which will be invoked?Can we create instance of base class and store it to derive class?Can we create derive class object inside base class, and if create instance of child class then what will happen?Can we inherit child class from 2 base classes? if yes then how? If not then why?Does C# support Multiple Inheritance?Why multiple inheritance is not supported in C# and why it’s supported in C++?How is multiple inheritance achieved in C#?What are Access Modifiers? Explain private, public, protected, internal, protected internal access modifiersWhat are the default access modifiers of the class?Why classes cannot be declared as protected?Can we declare private class in namespace?What are the valid access specifier used for the declaration of class at namespace level? If we inherit a class, do the private variables also get inherited?Can you prevent your class from being inherited?Can you prevent your class from being inherited without using sealed keyword?What is abstraction?What is encapsulation?What is the difference between abstraction and encapsulation?What is polymorphism?What is static or compile time polymorphism?What is runtime polymorphism or late binding or dynamic binding?What is method overloading?When and why we should use overload methods?What is inheritance based overloading?What are the advantages of using overloading?Can we overload the method in the same class?What is the execution control flow in overloaded methods?What is method overriding?What s virtual keyword?What are the key points to make the method as overridden?When it is must to override the method?When a derived class can overrides the base class member?Can we declare fields inside the class as virtual?When we treat sub-class method as an overriding method?Can we override private virtual method in c#?Can we override method in the same class?Can we execute parent class method if it is overridden in the child class?If we have virtual in base class and the same method is overridden in child class, by creating instance of child class and assign it to base class, then which of the method will be invoked first.What is the difference between method overloading and method overriding?What is method hiding?Can you access a hidden method in the derived which is declared in the base class?What is the difference between method overriding and method hiding?You have a component with 2 parameters and deployed to client side, now you have changed your method with 3 parameters, how can you deploy this without affecting the client code?What is operator overloading?What is abstract class and why we need of it?What are the rules of abstract classes?What is an abstract method?What is concrete method?When do you use abstract class in C#?When to use the abstract method in C#?
Previous
Next

What are the Nested Classes and why we use them?

Nested classes, also known as inner classes, are classes defined within another class. These classes have a unique relationship with their enclosing class, allowing them to access its members and vice versa. Nested classes can be categorized into four types: static nested classes, non-static (inner) nested classes, local classes, and anonymous classes.

1. Static Nested Classes:
These are static classes defined within another class. They are essentially separate classes that are just nested for organizational purposes. They can access static members of the enclosing class and can be accessed using the enclosing class's name. They are commonly used to group related utility classes or to encapsulate helper classes that are closely related to the outer class.

In C#, you can declare a static nested class within an outer (enclosing) class. A static nested class is a class that is associated with the outer class, but it doesn't require an instance of the outer class to be created. It's essentially a separate class that is organized within the scope of the outer class. Static nested classes are often used for grouping related utility classes or encapsulating helper functionality that is closely related to the outer class.

Here's an example of how you can declare and use a static nested class in C#: 


using System;

public class OuterClass
{
    public static class NestedStaticClass
    {
        public static void PrintMessage()
        {
            Console.WriteLine("Hello from the nested static class!");
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Access the nested static class without creating an instance of the outer class
        OuterClass.NestedStaticClass.PrintMessage();
    }
}

In this example, the 'NestedStaticClass' is declared as a static nested class within the 'OuterClass'. You can access the static methods of the nested class directly using the outer class's name, without needing to create an instance of the outer class.

Key points to remember about static nested classes in C#:

  1. Static nested classes cannot access the non-static members (fields, methods) of the outer class directly, unless those members are also declared as static.
  2. Static nested classes are useful for creating utility classes or grouping related functionality together in a modular way.
  3. They don't have access to instance-specific information of the outer class because they don't require an instance of the outer class to be created.
  4. Since they are defined within the scope of the outer class, they have access to the private members of the outer class.
  5. Unlike non-static (inner) classes, static nested classes don't have an inherent relationship with an instance of the outer class.

2. Non-Static (Inner) Nested Classes:
These are non-static classes defined within another class. They have access to both static and instance members of the enclosing class. In addition, they can also access the private members of the enclosing class, which can be useful for encapsulation and data hiding. Inner classes are often used when a class needs to be closely tied to another class, and their interaction is so strong that they should not be used by other classes.

Non-static (inner) nested classes are classes defined within an outer class and have a closer relationship with instances of the outer class. They can access both the static and instance members of the outer class. Here's an example of how you can use a non-static nested class in C#: 


using System;

public class OuterClass
{
    private string outerMessage = "Hello from the outer class!";

    public class InnerClass
    {
        public void PrintMessageFromOuter()
        {
            // Access the instance member of the outer class
            OuterClass outerInstance = new OuterClass();
            Console.WriteLine(outerInstance.outerMessage);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        OuterClass outerInstance = new OuterClass();

        // Create an instance of the inner class
        OuterClass.InnerClass innerInstance = new OuterClass.InnerClass();

        // Call the method of the inner class that accesses the outer class's member
        innerInstance.PrintMessageFromOuter();
    }
}

In this example, the 'InnerClass' is a non-static nested class defined within the 'OuterClass'. It has access to the private instance member 'outerMessage' of the outer class, as well as to its public members.

Using an object of the outer class to access methods of an inner class is not allowed and will result in a compilation error.

To achieve this, it's necessary to instantiate the inner class using the syntax OuterClass.InnerClass from an external context. 


OuterClass.Inner obj = new OuterClass.InnerClas();

Key points to remember about non-static nested classes (inner classes) in C#:

  1. Non-static nested classes have access to both static and instance members of the outer class.
  2. They can also access the private members of the outer class, which can be useful for encapsulation and data hiding.
  3. Instances of the inner class are usually created through instances of the outer class.
  4. Inner classes are useful when you need a class that's tightly related to the outer class and their interaction is so strong that they should not be used independently.
  5. The inner class has a reference to an instance of the outer class, so be mindful of potential memory and lifetime considerations.
  6. To create an instance of an inner class, you usually need to use the syntax OuterClass.InnerClass.

3. Local Classes:
Local classes are defined within a block of code, such as within a method or a constructor. They are not accessible outside of that block. Local classes have access to the members of the enclosing class and local variables that are effectively final (variables that are not re-assigned within the block). Local classes are used when you need a class that is specific to a particular context within a method or constructor.

Here's an example of how you can declare a local class within a method in C#: 


using System;

class OuterClass
{
    public void SomeMethod()
    {
        // Define a local class within the method
        class LocalClass
        {
            public void PrintMessage()
            {
                Console.WriteLine("Hello from the local class!");
            }
        }

        // Create an instance of the local class
        LocalClass localInstance = new LocalClass();

        // Call the method of the local class
        localInstance.PrintMessage();
    }
}

class Program
{
    static void Main(string[] args)
    {
        OuterClass outerInstance = new OuterClass();
        outerInstance.SomeMethod();
    }
}

In this example, the LocalClass is defined within the SomeMethod of the OuterClass. It has access to the method's variables and parameters and can be used within the method. However, it's not accessible outside of the method.

4. Anonymous Classes:
Anonymous classes are a special type of local class that do not have a name. They are often used to define and instantiate a class in a single expression. Anonymous classes are commonly used for implementing interfaces or extending classes in situations where you need a one-off implementation or customization of behavior.

Reasons to use nested classes:

  1. Encapsulation and Organizational Structure: Nested classes allow you to group related classes together, enhancing code organization and encapsulation. They can help avoid polluting the global namespace with classes that are only relevant within a specific context.
  2. Enhanced Readability: By placing related classes close to each other, you improve the readability of your code. This is particularly useful when a nested class is closely related to its enclosing class and their interaction needs to be understood together.
  3. Access Control: Inner classes can access private members of the enclosing class, which can help maintain encapsulation while allowing specific classes to interact more intimately with each other.
  4. Reduced Class Scope: Local classes and anonymous classes limit the scope of the class to the specific block in which they are defined, reducing the chances of name conflicts and promoting a more focused design.
  5. Implementation of Complex Logic: In some cases, nested classes can be used to implement complex logic in a more modular and organized way. This can lead to better maintainability and easier comprehension of the code.

Overall, nested classes provide a powerful tool for structuring and organizing your code, improving encapsulation, and facilitating interaction between closely related components. However, it's important to use them judiciously and consider the trade-offs in terms of code readability and complexity.

Previous
Next