Q1. Explain namespace in detail?

Ans:-
A namespace in C# is a way to organize and manage code, especially in
larger projects, by grouping related classes, interfaces, structs, enums,
and delegates together. Think of it as a container or a folder that helps
avoid naming conflicts and makes code more readable and
maintainable.
1. Purpose of Namespaces:
● Organization: They help organize code logically, making it easier to
manage, especially in large projects.
● Avoiding Naming Conflicts: Different classes can have the same
name as long as they belong to different namespaces.
2. Syntax:
namespace MyNamespace
{
public class MyClass
{
// class members
}
}
3. Using Namespaces:
● To use a class from another namespace, you typically include a
using directive at the top of your file:
using MyNamespace;

public class AnotherClass

{
MyClass obj = new MyClass();
}

4. Nested Namespaces:
● Namespaces can be nested, allowing for further organization
namespace OuterNamespace
{
namespace InnerNamespace
{
 public class InnerClass
{
// class members
}
}
}

5. Global Namespace:
● The global namespace is the root namespace. If you want to
ensure you are referring to something in the global namespace,
you can use the global:: prefix.
6. Partial Classes and Namespaces:
● You can split a class definition across multiple files, and as long as
they are in the same namespace, they will be compiled as a single
class.
using MyApp.Logging;
using System.Logging;

MyApp.Logging.Logger appLogger = new MyApp.Logging.Logger();

System.Logging.Logger sysLogger = new System.Logging.Logger();

Namespaces help maintain a clean, understandable, and conflict-free

codebase, especially in complex and large-scale applications.
Q2. Discuss different types of inheritance?
Ans:-
Inheritance in C# is a fundamental concept in object-oriented
programming that allows a class to inherit properties, methods, and
other members from another class. Let’s discuss two common types of
inheritance: Single Inheritance and Multilevel Inheritance.
1. Single Inheritance:
● Definition: In single inheritance, a class (called the derived or child
class) inherits from just one base (or parent) class. This is the
most straightforward form of inheritance.
● Example
// Base class
public class Animal
{
public void Eat()
{
Console.WriteLine("Eating...");
}
}

// Derived class
public class Dog : Animal
{
public void Bark()
{
Console.WriteLine("Barking...");
}
}

● Explanation: Here, Dog is the derived class that inherits from the
Animal base class. This means Dog has access to the Eat() method
defined in Animal, in addition to its own Bark() method.
2. Multilevel Inheritance:
● Definition: In multilevel inheritance, a class is derived from another
class, which is itself derived from another class. This creates a
chain of inheritance.
● Example:
// Base class
public class Animal
{
public void Eat()
{
Console.WriteLine("Eating...");
}
}

// Derived class
public class Mammal : Animal
{
public void Breathe()
{
Console.WriteLine("Breathing...");
}
}

// Further derived class

public class Dog : Mammal
{
public void Bark()
{
Console.WriteLine("Barking...");
}
}
Q3. Explain Method in Detail?
Ans:-
A method in C# is a block of code that performs a specific task. Methods
are used to organize code into reusable pieces, making your programs
more modular and easier to understand.
Syntax of a Method:
[access_modifier] return_type MethodName(parameter_list)
{
// Method body: code that defines what the method does
}

Components of a Method:
1. Access Modifier:
○ Definition: Determines the visibility of the method to other
classes.
○ Common Modifiers:
■ public: The method can be accessed from any other
class.
■ private: The method can only be accessed within the
class it is defined.
■ protected: The method can be accessed within its class
and by derived classes.
■ internal: The method can be accessed within the same
assembly.
2. Return Type:
○ Definition: Specifies the type of value the method returns.
○ Examples:
■ void: The method does not return a value.
■ int: The method returns an integer.
■ string: The method returns a string.
3. Method Name:
○ Definition: The name of the method, which should be
descriptive of its functionality.
○ Naming Convention: Typically written in PascalCase.
4. Parameter List:
 ○ Definition: A comma-separated list of parameters that the
method takes as input.
○ Syntax: Each parameter is defined by a type and a name, e.g.,
int number.
○ Optional Parameters: You can also define default values for
parameters.
5. Method Body:
○ Definition: The block of code inside the curly braces {} that
defines what the method does.
○ Example: This is where you write the logic that should be
executed when the method is called.
Example of a Method:
public int AddNumbers(int a, int b)
{
int result = a + b;
return result; // This returns the sum of a and b
}
Q4. What is Typecasting & Explain its types?
Ans:-
Type casting in C# is the process of converting a variable from one data
type to another. It is necessary when you need to assign a value of one
type to a variable of another type, especially when those types are not
automatically compatible.
Types of Type Casting:
1. Implicit Casting (Automatic Type Conversion):
○ Definition: This happens automatically when converting a
smaller data type to a larger data type. No special syntax is
needed because there is no risk of data loss.
○ Example:
int num = 10;
double decimalNum = num; // Implicit casting from int to double

Explicit Casting (Manual Type Conversion):

● Definition: This requires the use of a cast operator because you're
converting a larger data type into a smaller one, or between
incompatible types. It’s called "explicit" because you have to
specify the type you want to convert to.
● Example:
double decimalNum = 9.78;
int num = (int)decimalNum; // Explicit casting from double to int

Other Types of Casting:

● Boxing and Unboxing:
○ Boxing: Converting a value type (like int, double) into an
object type.
int num = 123;
object obj = num; // Boxing

Unboxing: Extracting the value type from an object type.

object obj = 123;
int num = (int)obj; // Unboxing

Q5. Write Short Note on .NET Framework?

Ans:-
The .NET Framework is a software development platform developed by
Microsoft. It provides a controlled environment for developing and
running applications primarily built on Windows. In the context of C#
and Advanced Web Programming, the .NET Framework plays a crucial
role.
Key Features of .NET Framework:
1. Common Language Runtime (CLR):
○ Definition: The heart of the .NET Framework, CLR manages
the execution of .NET programs. It handles memory
management, exception handling, and security.
○ Role: It allows C# code to be compiled into Intermediate
Language (IL) and executed on any machine with the CLR
installed.
2. Framework Class Library (FCL):
○ Definition: A vast collection of reusable classes, interfaces,
and data structures that developers can use to build
applications.
○ Role: Provides functionality for tasks like file handling,
database interaction, and web services.
3. Language Interoperability:
○ Definition: .NET supports multiple programming languages,
such as C#, VB.NET, and F#. All these languages can work
together seamlessly.
○ Role: Allows developers to choose the language best suited
for their task while still integrating with the entire .NET
ecosystem.
4. ASP.NET:
○ Definition: A part of the .NET Framework used for building
web applications and services.
○ Role: Allows developers to create dynamic, data-driven
websites using C# and other .NET languages.
5. Windows Forms and WPF:
○ Definition: These are libraries within the .NET Framework
used for building desktop applications.
 ○ Role: Provides tools for creating rich user interfaces in
desktop applications.
Importance in C#:
● The .NET Framework is the foundation on which C# applications
are built. It provides the tools and libraries necessary for
developing robust and scalable web, desktop, and mobile
applications.
Q.6 Explain about OOPS Features?
Ans:-
1. Encapsulation
Encapsulation means putting together the data and the functions that
use that data into a single unit called a class. It also means hiding the
details from the outside world.
Keeps data safe and makes it easier to use.
● Example
public class Person
{
private string name; // Hidden from outside

public string Name // Public property to access and change the name
{
get { return name; }
set { name = value; }
}

public void Greet()

{
Console.WriteLine("Hello, my name is " + Name);
}
}

2. Inheritance
● What It Is: Inheritance lets you create a new class based on an
existing class. The new class inherits the features (methods and
properties) of the old class.
● Why It’s Useful: Reuse code and build on existing functionality.
● Example:
public class Animal
{
public void Eat()
{
Console.WriteLine("Eating...");
}
}

public class Dog : Animal

{
public void Bark()
{
Console.WriteLine("Barking...");
}
}

3. Polymorphism
● What It Is: Polymorphism allows you to use a single name for
different types of operations. It lets one method do different things
based on what it's acting on.
● Why It’s Useful: Makes your code more flexible and easier to
manage.
● Example:
○ Method Overloading: Different methods with the same name
but different parameters.
public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)

{
return a + b;
}
}

Method Overriding: Changing how a method works in a derived class.

public class Animal

{
 public virtual void MakeSound()
{
Console.WriteLine("Some sound...");
}
}

public class Dog : Animal

{
public override void MakeSound()
{
Console.WriteLine("Bark");
}
}

4. Abstraction
● What It Is: Abstraction hides complex details and shows only the
essential features. It’s like using a TV remote without knowing how
it works inside.
● Why It’s Useful: Simplifies how you interact with complex systems.
● Example:
public abstract class Shape
{
public abstract void Draw(); // No implementation here
}

public class Circle : Shape

{
public override void Draw()
{
Console.WriteLine("Drawing a Circle");
}
}