Viva - OOP Question C#

OOP Question

a.       Beginner

1.       Explain the basic features of OOPs

http://www.codeproject.com/Articles/838365/Basic-Csharp-OOPS-Concept
http://www.c-sharpcorner.com/UploadFile/asmabegam/basic-concept-of-oop-in-C-Sharp/

Important features of Object Oriented programming are:

• Inheritance
• Polymorphism
• Data Hiding
• Encapsulation
• abstraction
• Overloading
• Reusability 
  
  
  

Inheritance  is a mechanism in which one object acquires all the properties and behaviors of a parent object. 

1. Encapsulation is to hide the member or variable to outside class.

Encapsulation : Wrapping up of data and methods into a single unit is Encapsulation (e.g. Class)

Encapsulation is used for hide the code and data in a single unit to protect the data from the outside the world.
It solves the problem in implementation level.

2.       What is polymorphism?

Polymorphism Mean by more than one form. Ability to provide different implementation based on different number/type of parameters.

Example:

               class A1

        {

    void hello()

              { Console.WriteLine(“Hello”); }

          void hello(string s)

              { Console.WriteLine(“Hello {0}”,s); }

        }

 3.       Difference abstraction and encapsulation?

Encapsulation : Wrapping up of data and methods into a single unit is Encapsulation (e.g. Class)

Abstraction : It is an act of representing only the essential things without including background details. (e.g. Interface)

Abstraction is used for hide the data and giving relevant information.
It solves the problem in design level itself.

Encapsulation:
Encapsulation is used for hide the code and data in a single unit to protect the data from the outside the world.
It solves the problem in implementation level.

 4.       What is difference between Overloading and Overriding?

When overriding a method, you change the behavior of the method for the derived class. Overloading a method simply involves having another method with the same name within the class

5.       What is static class and method?

A class in C sharp declared with static keyword is a C# static class. The static class prevents the object creation and can be used directly without creating any instance of class. A class that is not a static class is used after creating its object with new keyword. But the class that is static is used directly without creating its object.

Static methods have no instances. They are called with the type name, not an instance identifier. They are slightly faster than instance methods because of this. Static methods can be public or private

 6.       How can you prevent your class to be inherited further?

             The keyword “sealed” will prevent the class from being inherited.

 7.       Difference between abstract and interface

Feature	Interface	Abstract class
Multiple inheritance	A class may inherit several interfaces.	A class may inherit only one abstract class.
Default implementation	An interface cannot provide any code, just the signature.	An abstract class can provide complete, default code and/or just the details that have to be overridden.
Access Modfiers	An interface cannot have access modifiers for the subs, functions, properties etc everything is assumed as public	An abstract class can contain access modifiers for the subs, functions, properties
Homogeneity	If various implementations only share method signatures then it is better to use Interfaces.	If various implementations are of the same kind and use common behaviour or status then abstract class is better to use.

8.       Difference between class and structure

Structs are value-type variables and are thus saved on the stack, additional overhead but faster retrieval. Another difference is that structs cannot inherit

9.       What are the access modifiers?

·         public - The members (Functions & Variables) declared as public can be accessed from anywhere.

·         private - Private members cannot be accessed from outside the class. This is the default access specifier for a member, i.e if you do not specify an access specifier for a member (variable or function), it will be private. Therefore, string PhoneNumber; is equivalent to private string PhoneNumber;

·         protected - Protected members can be accessed only from the child classes.

internal - Internal members can be accessed from anywhere within the application. This is the default access specifier for a class.

10.   What is shadowing or hiding?

Shadowing hides a method in a base class. Using the example in the question you linked:

class A

{

   public int Foo()

     {

            return 5;

     }

   public virtual int Bar()

     {

            return 5;

     }

}

class B : A

{

   public new int Foo()

     {

     return 1;

     }

   public override int Bar()

     {

     return 1;

     }

}

Class B overrides the virtual method Bar. It hides (shadows) the non-virtual method Foo. Override uses the override keyword. Shadowing is done with the new keyword.

In the code above, if you didn't use the new keyword when defining the Foo method in class B, you would get this compiler warning:

'test.B.Foo()' hides inherited member 'test.A.Foo()'. Use the new keyword if hiding was intended.

11.   Difference between Namespace and Assembly?

Namespace: Namespaces are the logical component that consist of many classes.Within a namespace, you can declare one or more of the following types:

1. another namespace

2. class

3. interface

4. struct

5. enum

6. delegate


Assembly :

An Assembly can contain many namespaces. Assemblies contain MSIL code.
Assemblies are Self-Describing. [e.g. metadata,manifest]

Differences:
1)A namespace is logically groups classes.An assembly is physical grouping of logical units.
2)An Assembly contains one or more namespaces

b.      Intermediate

12.   What are generics?

Generics provide the ability to create type-safe collections in .NET.
In other words, generics allow you to write a class or method that can work with any data type.

 

13.   What is a delegate and event?

·         A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked.

·   Every action is a an event.In GUI all the controls have the

event action.For example Button,it has the click,double

click,key press,key up,key down,mouse move,mouse up,mouse

down like that.When you can generate the set of task based

on the event.

http://www.tutorialsteacher.com/csharp/csharp-func-delegate

14.   Can we have Sealed Method in abstract class?

Answer:
Looking at first site the The Keyword Sealed & Abstract are contradictory to each other..In simple terms we can Say Answer is NO...

Look the code below

using System;
abstract class A
{
public abstract void Hello();

public sealed void Hi();
}

when we will complie the code.. we will get the Compile time Error as below

'A.Hi()' cannot be sealed because it is not an override..

But We can have Sealed methods in abstract class when the abstract class is Dervided class .. for Eg.

using System;

class A
{
public virtual void Hello()
{
Console.WriteLine(" Say Hello");
}

}

abstract class B : A
{
public sealed override void Hello()
{
Console.WriteLine(" Say Hi");
}

}
class C : B
{

}
class Demo
{
public static void Main()
{
C c1 = new C();
c1.Hello();// Output is Say Hi
}
}

Can we have an Abstract class without having any abstract method?

No at least one method must be abastract

15.   Can we have Multiple Main Methods in one .cs file?

No

16.   What is the default access modifier of a class?

by Default Internal is the access modifier of class

17.   How does Composition mechanism works?

c.       Advance

18.   Can you override private virtual methods?

No, you cannot access private methods in inherited classes.

19.   Can you prevent your class from being inherited and becoming a base class for some other classes?

Yes. The keyword “sealed” will prevent the class from being inherited.

20.   Can you allow class to be inherited, but prevent the method from being over-ridden?

Yes. Just leave the class public and make the method sealed.

21.   Why can't you specify the accessibility modifier for methods inside the interface?

They all must be public, and are therefore public by default.

22.   Static data members should be initialized inside the constructor. True or False.

False. Static datamembers should not be initialised inside constructor.

23.   What are OOP designs Principles?

DRY
https://dotnetcodr.com/2013/10/17/the-dont-repeat-yourself-dry-design-principle-in-net-part-1/
https://dotnetcodr.com/architecture-and-patterns/

KISS 
https://www.c-sharpcorner.com/article/software-design-principles-dry-kiss-yagni/
S O L I D

According to Wikipedia the definition of SOLID is   

" SOLID are guidelines that can be applied while working on software to remove code smells by causing the programmer to refactor the software's source code until it is both legible and extensible. " 

S –Single responsibility principle

Wikipedia defines it as “every class should have a single responsibility, and that responsibility should be entirely encapsulated by the class”.

O –Open/closed principle

Wikipedia definition says “software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification”

·         Software entities (classes, modules, etc) should be open for extension, but closed for modification.

·         In other words, (in an ideal world...) you should never need to change existing code or classes: All new functionality can be added by adding new subclasses and overriding methods, or by reusing existing code through delegation.

·         This prevents you from introducing new bugs in existing code. If you never change it, you can't break it.

L – Liskov Substitution Principle

• Subtypes must be substitutable for their base types.

·         Derived classes must be usable through the base class interface without the need for the user to know the difference.

·          "An instance of a derived should be able to replace any instance of its superclass"

I – Interface Segregation Principle

• Clients should not be forced to depend upon interfaces that they do not use.
• ·         Many client specific interfaces are better than one general purpose interface

·         The dependency of one class to another one should depend on the smallest possible  interface

D – Dependency Injection / Inversion Principle:  .Net MVC fully utilizing this principle.

Wikipedia: The principle states:  

A. High-level modules should not depend on low-level modules. Both should depend on abstractions.
 B. Abstractions should not depend upon details. Details should depend upon abstractions.

Dependency Injection (DI) vs. Inversion of Control (IOC)

The main goal of Inversion of control and Dependency Injection is to remove dependencies of an application. This makes the system more decoupled and maintainable

ersion of control	Dependency injection
It’s a generic term and implemented in several ways (events, delegates etc).	DI is a subtype of IOC and is implemented by constructor injection, setter injection or method injection.

http://mohammadnazmul.blogspot.com/2014/05/solid.html
https://www.codeproject.com/Articles/703634/SOLID-architecture-principles-using-simple-Csharp
Delegate 
http://www.tutorialsteacher.com/csharp/csharp-func-delegate http://www.c-sharpcorner.com/UploadFile/8911c4/simple-delegates-with-examples-in-C-Sharp/
http://www.tutorialspoint.com/csharp/csharp_delegates.htm

Before applying the delegate:

protected void Page_Load(object sender, EventArgs e)
{

    if (!IsPostBack)
    {
        GetData("Mahesh");
    }
}
public void GetData(string Name)
{
    lblName.Text = Name;
}

Output

Mahesh

After applying the delegate:  

public delegate void MyDelegare(string var);
protected void Page_Load(object sender, EventArgs e)

{
    if (!IsPostBack)
    {
        MyDelegare objMyDelegare = new MyDelegare(GetData);
        objMyDelegare("Mahesh");
    }
}
public void GetData(string Name)
{
    lblName.Text = Name;
}

Output

Mahesh

What is reflection?

All .NET assemblies have metadata information stored about the types defined in modules. This

metadata information can be accessed by mechanism called as “Reflection”.System. Reflection

can be used to browse through the metadata information.

Generics
http://tech.priyo.com/tutorial/2014/11/18/26914.html
refer to a feature in C# that allows defining a class or method with type as a parameter.  
Generics allow for designing a classes and methods whose types are specified only at the time of declaration and instantiation.
The List<T> collection class is an example for generic class

benefits in using generics include:

• Casting is not required for accessing each element in the collection

class Test<T>
{
    T _value;

    public Test(T t)
    {
 // The field has the same type as the parameter.
 this._value = t;
    }

    public void Write()
    {
 Console.WriteLine(this._value);
    }
}

class Program
{
    static void Main()
    {
 // Use the generic type Test with an int type parameter.
 Test<int> test1 = new Test<int>(5);
 // Call the Write method.
 test1.Write();

 // Use the generic type Test with a string type parameter.
 Test<string> test2 = new Test<string>("cat");
 test2.Write();
    }
}

Output

5
cat

using System;
using System.Collections.Generic;

class Program
{
    static List<T> GetInitializedList<T>(T value, int count)
    {
 // This generic method returns a List with ten elements initialized.
 // ... It uses a type parameter.
 // ... It uses the "open type" T.
 List<T> list = new List<T>();
 for (int i = 0; i < count; i++)
 {
     list.Add(value);
 }
 return list;
    }

    static void Main()
    {
 // Use the generic method.
 // ... Specifying the type parameter is optional here.
 // ... Then print the results.
 List<bool> list1 = GetInitializedList(true, 5);
 List<string> list2 = GetInitializedList<string>("Perls", 3);
 foreach (bool value in list1)
 {
     Console.WriteLine(value);
 }
 foreach (string value in list2)
 {
     Console.WriteLine(value);
 }
    }
}

Output

True
True
True
True
True
Perls
Perls
Perls

http://www.dotnet-tricks.com/Tutorial/csharp/FU4N141113-Difference-Between-Constant-and-ReadOnly-and-Static.html

Constants:

1. Constants can be assigned values only at the time of declaration

2. Constant variables have to be accessed using "Classname.VariableName"

3. Constants are known at compile time

Read Only:

1. Read only variables can be assigned values either at runtime or at the time of instance initialization via constructor

2. Read only variables have to be accessed using the "InstanceName.VariableName"

3. Read only variables are known at run time.

const variables can declared in methods ,while readonly fields cannot be declared in methods

enum 

An enumeration is a set of named integer constants. An enumerated type is declared using the enum keyword

class EnumProgram
   {
      enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

      static void Main(string[] args)
      {
         int WeekdayStart = (int)Days.Mon;
         int WeekdayEnd = (int)Days.Fri;
         Console.WriteLine("Monday: {0}", WeekdayStart);
         Console.WriteLine("Friday: {0}", WeekdayEnd);
         Console.ReadKey();
      }
   }
}

When the above code is compiled and executed, it produces the following result:

Monday: 1
Friday: 5

struct 

struct Books
{
   public string title;
   public string author;
   public string subject;
   public int book_id;
};  

public class testStructure
{
   public static void Main(string[] args)
   {

      Books Book1;        /* Declare Book1 of type Book */
      Books Book2;        /* Declare Book2 of type Book */

      /* book 1 specification */
      Book1.title = "C Programming";
      Book1.author = "Nuha Ali"; 
      Book1.subject = "C Programming Tutorial";
      Book1.book_id = 6495407;

      /* book 2 specification */
      Book2.title = "Telecom Billing";
      Book2.author = "Zara Ali";
      Book2.subject =  "Telecom Billing Tutorial";
      Book2.book_id = 6495700;

      /* print Book1 info */
      Console.WriteLine( "Book 1 title : {0}", Book1.title);
      Console.WriteLine("Book 1 author : {0}", Book1.author);
      Console.WriteLine("Book 1 subject : {0}", Book1.subject);
      Console.WriteLine("Book 1 book_id :{0}", Book1.book_id);

http://www.herongyang.com/C-Sharp/Intermediate-Language-Compile-and-Run-C-Sharp-Program.html

What is .Net Framework ?

The .NET framework is a programming framework from Microsoft. Developers can use .Net Framework to develop applications,install and run the application on Windows operating systems.

What is Common Language Runtime (CLR) ?

Common Language Runtime or CLR is the run-time execution environment of .Net Framework. Converting MS-IL into platform or OS specific code is done by CLR. .

What is MS-IL (Microsoft Intermediate Language) ?

When a program is complied in .Net , the source code will be converted into an intermediate language called  Microsoft Intermediate Language (MS-IL) . This is done by Just-In time Compiler (JIT)

https://www.youtube.com/watch?v=Mz9BlmST31w&list=PLym69wpbTIIEOesltWGUsVnY9HDWbJit_

https://www.youtube.com/watch?v=umfhcv-UxxQ&list=PLiceGnDCE4Xbtd2y-i8v4PfLp47SX6MkV&index=2

https://www.youtube.com/watch?v=sx2U8kQ3DLM&list=PLKiZXxQe7OiC2RzvzDCKmSn-7ZdsXLeSF

https://www.youtube.com/watch?v=_pgUO1iz8Ps&t=9s

Extension Methods

Scoped (সীমিত)

• ব্যবহার: একটি HTTP request এর জন্য একটি instance তৈরি হয় এবং সেই request-এর মধ্যে যতবার দরকার হয়, একই instance ব্যবহার হয়।

• উদাহরণ:
  DbContext সাধারণত Scoped হিসেবে রেজিস্টার করা হয়, যাতে একটি request-এর মধ্যে একই database connection ব্যবহার হয়।

• কখন ব্যবহার করবেন:
  যখন সার্ভিসটি request-specific data নিয়ে কাজ করে।

• কোড উদাহরণ:

  C#

  services.AddScoped<IOrderService, OrderService>();

---

3️⃣ Singleton (একক)

• ব্যবহার: অ্যাপ্লিকেশন চালু হওয়ার সময় একটি instance তৈরি হয় এবং পুরো অ্যাপ্লিকেশন জুড়ে সেটি ব্যবহার হয়।

• উদাহরণ:
  Logging service বা configuration service সাধারণত Singleton হিসেবে ব্যবহৃত হয়।

• কখন ব্যবহার করবেন:
  যখন সার্ভিসটি shared state বা global configuration নিয়ে কাজ করে এবং বারবার নতুন instance দরকার হয় না।

• কোড উদাহরণ:

  C#

  services.AddSingleton<ILogService, LogService>();

---

📊 তুলনামূলক চার্ট

Lifecycle	Instance তৈরি হয়	Reuse হয়	উপযুক্ত ক্ষেত্র
Transient	প্রতিবার	না	Stateless service
Scoped	প্রতি request	হ্যাঁ	Request-specific service
Singleton	একবার	হ্যাঁ	Global/shared service

ধরুন আপনি একটি ই-কমার্স ওয়েবসাইট তৈরি করেছেন যেখানে একজন ব্যবহারকারী একটি HTTP request-এর মাধ্যমে তার shopping cart-এ পণ্য যোগ করে।

C#

services.AddScoped<ICartService, CartService>();

✅ কেন Scoped?

• একটি request-এর মধ্যে cart-এর অবস্থা (state) ধরে রাখতে হয়
• একই request-এর মধ্যে বারবার একই instance ব্যবহার করতে হয়
• performance এবং consistency বজায় রাখতে সাহায্য করে

🧠 বাস্তব চিত্র:

যখন একজন ব্যবহারকারী checkout পেজে যায়, তখন CartService instance তৈরি হয় এবং সেই request-এর মধ্যে যতবার cart data দরকার হয়, একই instance ব্যবহার হয়। এতে করে cart-এর অবস্থা ঠিক থাকে এবং বারবার নতুন instance তৈরি করতে হয় না।

📊 তুলনামূলক বাস্তব উদাহরণ

Scenario	Lifecycle	Reason
ইমেইল পাঠানো	Transient	Stateless, প্রতি বার নতুন instance দরকার
Checkout পেজে cart পরিচালনা	Scoped	Stateful, request-specific instance দরকার
Logging service	Singleton	পুরো অ্যাপ্লিকেশনে একই instance দরকার

Transient objects are always different; a new instance is provided to every controller and every service.

Scoped objects are the same within a request, but different across different requests.

Singleton objects are the same for every object and every request.

https://www.dofactory.com/code-examples/csharp/service-lifetimes

https://www.tutorialspoint.com/what-is-the-addsingleton-vs-addscoped-vs-add-transient-chash-asp-net-core

Filters in ASP.NET Core allow code to be run before or after specific stages in the request processing pipeline.

What's the Difference and When to Use?

In C#, records and classes look similar but serve different purposes. Knowing when to use each can improve performance, organization, and readability of your code.

🔹Classes are ideal for objects that can change state.
- Best for: Database entities, domain models, objects that need state changes.

🔹Records are immutable by default and compared by value.
- Best for: DTOs, API response models, objects that shouldn't be modified.

✅ When to Use Records?
- Immutable objects
- Value-based comparison
- DTOs and API responses

❌ When to Avoid?
- If you need mutable objects
- If using Entity Framework, which requires mutability

Have you used records in your projects?

𝐒𝐮𝐦𝐦𝐚𝐫𝐲:
- 𝐈𝐄𝐧𝐮𝐦𝐞𝐫𝐚𝐛𝐥𝐞<𝐓>: Read-only, used for iteration.
- 𝐈𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧<𝐓>: Adds collection manipulation (add/remove).
- 𝐈𝐋𝐢𝐬𝐭<𝐓>: Supports indexing and collection manipulation.

1. 𝐈𝐄𝐧𝐮𝐦𝐞𝐫𝐚𝐛𝐥𝐞<𝐓>
🔍 𝐏𝐮𝐫𝐩𝐨𝐬𝐞: It represents a read-only forward-only collection of items.
🛠️ 𝐂𝐨𝐦𝐦𝐨𝐧 𝐔𝐬𝐞: Ideal for iterating through a collection using a foreach loop.
🚫 𝐂𝐚𝐧𝐧𝐨𝐭 𝐦𝐨𝐝𝐢𝐟𝐲: It doesn't allow adding, removing, or modifying elements.
📖 𝐄𝐱𝐚𝐦𝐩𝐥𝐞: LINQ queries often return IEnumerable.
2. 𝐈𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧<𝐓>
💼 𝐏𝐮𝐫𝐩𝐨𝐬𝐞: Extends IEnumerable with additional features like adding, removing, and checking the size of a collection.
➕ 𝐒𝐮𝐩𝐩𝐨𝐫𝐭𝐬 𝐀𝐝𝐝/𝐑𝐞𝐦𝐨𝐯𝐞: Unlike IEnumerable, you can modify the collection.
🏗️ 𝐔𝐬𝐞 𝐰𝐡𝐞𝐧: You need collection manipulation without requiring indexing.
3. 𝐈𝐋𝐢𝐬𝐭<𝐓>
📚 𝐏𝐮𝐫𝐩𝐨𝐬𝐞: Extends ICollection with the ability to access elements by index.
🔢 𝐒𝐮𝐩𝐩𝐨𝐫𝐭𝐬 𝐈𝐧𝐝𝐞𝐱𝐢𝐧𝐠: You can access and modify elements using an index, like an array.
⚡𝐔𝐬𝐞 𝐰𝐡𝐞𝐧: You need direct access to elements via indexing along with modification capabilities.
4. 𝐋𝐢𝐬𝐭<𝐓>
🎯 𝐏𝐮𝐫𝐩𝐨𝐬𝐞: A concrete implementation of IList.
🔥 𝐌𝐨𝐬𝐭 𝐅𝐞𝐚𝐭𝐮𝐫𝐞𝐬: Offers all the functionalities of IList, ICollection, and IEnumerable.
🌱 𝐃𝐲𝐧𝐚𝐦𝐢𝐜 𝐒𝐢𝐳𝐞: Automatically resizes as elements are added or removed.
⚙️ 𝐔𝐬𝐞 𝐰𝐡𝐞𝐧: You need a resizable collection with full manipulation and indexing support.