NET Interview Questions

Question: What is the difference between a class and an object in .NET?

Answer:

In .NET (and in object-oriented programming in general), classes and objects are fundamental concepts, but they represent different aspects of the program.

Here’s the difference:

---

Class:

A class in .NET is a blueprint or template for creating objects. It defines the structure, behavior, and state of the objects created from it.

• Definition: A class defines properties, methods, fields, and events that represent the attributes and behaviors of the object.
• Type: A class is a data type. It doesn’t represent an actual instance of data or behavior, but a template for creating such instances.
• Function: A class is used to encapsulate logic and data that together define a type. It can be thought of as a user-defined type that serves as a foundation for creating objects.

Example of a Class in .NET:

public class Car
{
    // Properties (Attributes of the car)
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    // Method (Behavior of the car)
    public void StartEngine()
    {
        Console.WriteLine("Engine started");
    }
}

In this example:

• Car is a class that defines the properties Make, Model, and Year, along with a method StartEngine().
• The class Car itself doesn’t represent any specific car; it’s just a template.

---

Object:

An object is an instance of a class. When a class is defined, no memory is allocated for the class itself. Memory is only allocated when an object is created from the class.

• Definition: An object is an instance of a class. It represents an actual entity created from the blueprint of the class. When you create an object, you’re allocating memory for its state (fields and properties) and behavior (methods).
• Type: An object is an instance of a class and represents real data in your program.
• Function: An object holds real data and interacts with other objects and parts of the program. It is the entity that can perform actions (via methods) and hold values (via properties).

Example of an Object in .NET:

// Creating an object of the class Car
Car myCar = new Car();

// Setting properties of the object
myCar.Make = "Toyota";
myCar.Model = "Corolla";
myCar.Year = 2022;

// Calling a method on the object
myCar.StartEngine();

In this example:

• myCar is an object created from the Car class.
• myCar holds the data specific to this car (e.g., Make, Model, Year) and can perform behaviors (e.g., StartEngine()).

---

Key Differences:

Feature	Class	Object
Definition	A class is a blueprint or template for creating objects.	An object is an instance of a class.
Memory Allocation	No memory is allocated for the class itself.	Memory is allocated when an object is instantiated from a class.
Type	A class is a type definition (like a data type).	An object is an actual entity created based on the class type.
State	A class can contain the structure and behavior but has no state until instantiated.	An object contains actual data and state that represents real-world entities.
Purpose	Defines the properties, methods, and events that the object will have.	Represents real-world entities with actual data and behavior.
Instantiation	A class is not created directly; objects must be instantiated from it.	An object is created using the new keyword and the constructor of the class.

---

Real-World Analogy:

• Class: Think of a class as a blueprint for a house. It outlines how the house will be structured, how many rooms it will have, the windows, doors, etc., but it isn’t an actual house.

• Object: An object is an actual house built from that blueprint. Each house (object) has its own specific address, furniture, rooms, etc., but all of them follow the same design from the blueprint (class).

---

Conclusion:

• A class in .NET is a definition or template that describes the structure and behavior of objects, while an object is an instance of that class, representing real data and functionality.
• You can think of a class as a blueprint, and objects as the actual things built from that blueprint in memory.

Question: What is the Global Assembly Cache (GAC)?

Answer:

The Global Assembly Cache (GAC) is a central repository in the .NET Framework used to store shared assemblies that are intended to be used by multiple applications on a computer. It is designed to manage assemblies in a way that prevents version conflicts and ensures that applications can access the right version of a shared assembly, regardless of which application is using it.

---

Key Characteristics of the GAC:

1. Location:

   • The GAC is located in a specific directory on the system, typically:
     • For 32-bit systems: C:\Windows\Assembly
     • For 64-bit systems: C:\Windows\Microsoft.NET\Assembly
   • Assemblies stored in the GAC are accessible to all applications on the machine, as long as they reference the correct version of the assembly.

2. Shared Assemblies:

   • The GAC is used primarily for shared assemblies that multiple applications may rely on, like libraries or frameworks.
   • Unlike private assemblies, which are stored in the application’s directory, assemblies in the GAC are globally accessible, making it easier to reuse code across multiple applications without redundancy.

3. Strong Naming:

   • For an assembly to be placed in the GAC, it must be strongly named. This means the assembly must have a unique identity defined by:
     • Assembly name
     • Version number
     • Culture (optional)
     • Public key token (generated when the assembly is signed)
   • The strong name guarantees that different versions of an assembly can coexist in the GAC, preventing conflicts between applications that require different versions of the same assembly.

4. Versioning:

   • The GAC supports versioning of assemblies. This means that multiple versions of the same assembly can exist in the GAC at the same time. When an application references an assembly, it can specify the exact version it requires.
   • This versioning mechanism helps prevent the DLL Hell problem, where different applications could require different versions of the same shared library, leading to conflicts.

5. Installation:

   • Assemblies are added to the GAC using specific tools, such as:
     • gacutil (Global Assembly Cache Utility)
     • Windows Installer (for managed installation of applications)
     • ClickOnce (a deployment technology that can place assemblies in the GAC)

6. Security:

   • Assemblies in the GAC can be signed with a strong name and may also be associated with a specific code access security policy to define what actions the assembly is allowed to perform.
   • The GAC ensures that only assemblies that are correctly signed and meet security policies can be placed in the cache, preventing malicious or unauthorized assemblies from being used.

---

How to Use the GAC:

1. Adding an Assembly to the GAC:

   • You can add assemblies to the GAC using the gacutil tool:

     gacutil /i MyAssembly.dll

   • This command installs the assembly MyAssembly.dll into the GAC, making it available to all applications that require it.

2. Removing an Assembly from the GAC:

   • To remove an assembly, you can use:

     gacutil /u MyAssembly

   • This removes the specified assembly from the GAC.

3. Viewing Assemblies in the GAC:

   • You can browse the GAC via Windows Explorer or use the gacutil tool to list the assemblies:

     gacutil /l

4. Referencing Assemblies in the GAC:

   • In your .NET project, you can reference assemblies that are stored in the GAC just like you would reference any other assembly. The .NET runtime will automatically resolve references to assemblies in the GAC.

---

Benefits of the GAC:

1. Code Sharing:

   • The GAC allows assemblies to be shared across multiple applications, saving disk space and reducing redundancy. Applications can reference assemblies from the GAC instead of having their own copy of the same assembly.

2. Versioning:

   • Multiple versions of the same assembly can exist in the GAC, allowing applications to specify which version of an assembly they need. This avoids the problem of DLL Hell, where different applications on a system require different versions of the same DLL.

3. Centralized Management:

   • The GAC provides a centralized location to manage shared assemblies, making it easier to update, secure, and maintain common libraries used by multiple applications.

4. Security:

   • Assemblies placed in the GAC are required to be strongly named and are often subject to code access security. This helps ensure that only trusted, verified assemblies can be used by applications.

---

Examples:

1. Adding a .NET Framework Assembly to the GAC:

   • The .NET Framework itself, like System.dll, is often stored in the GAC. When a .NET application needs to reference this assembly, it doesn’t need to have a local copy of System.dll; it will simply use the version from the GAC.

2. Adding a Custom Assembly to the GAC:

   • If you have a custom class library, say MyLibrary.dll, that you want to share among several applications, you can add it to the GAC so that all your applications can reference the same version of MyLibrary.dll from the GAC.

---

Limitations and Considerations:

1. Strong Name Requirement:

   • Only assemblies with a strong name can be stored in the GAC, which requires you to sign the assembly with a key pair. This may add complexity to the build and deployment process.

2. Permissions:

   • Installing or removing assemblies in the GAC typically requires administrator permissions on the system.

3. Disk Space:

   • Storing many assemblies in the GAC can consume disk space, especially if multiple versions of the same assembly are stored.

4. Application Compatibility:

   • When deploying applications that rely on assemblies in the GAC, make sure the correct version of the assembly is available in the GAC on the target machine. Otherwise, applications might fail due to version mismatches.

---

Conclusion:

The Global Assembly Cache (GAC) is a crucial feature in the .NET Framework, providing a centralized storage location for shared assemblies. It allows assemblies to be reused across multiple applications, supports versioning to avoid conflicts, and ensures security through strong naming. By using the GAC, developers can manage shared libraries more efficiently, reduce duplication, and avoid versioning issues like DLL Hell.

Read More

If you can’t get enough from this article, Aihirely has plenty more related information, such as .NET interview questions, .NET interview experiences, and details about various .NET job positions. Click here to check it out.