Explore topic-wise InterviewSolutions in Current Affairs.

A SORTED HASHTABLE.

A sorted HashTable.

HashTable.

HashTable.

By CALLING SORT() and then REVERSE() METHODS.

By calling Sort() and then Reverse() methods.

The FIRST one performs a DEEP copy of the ARRAY, the SECOND one is shallow.

The first one performs a deep copy of the array, the second one is shallow.

No.

No.

STRINGBUILDER is more efficient in the CASES, where a lot of manipulation is done to the text. STRINGS are immutable, so each time it’s being operated on, a new instance is CREATED.

StringBuilder is more efficient in the cases, where a lot of manipulation is done to the text. Strings are immutable, so each time it’s being operated on, a new instance is created.

System.STRING is IMMUTABLE; System.StringBuilder was designed with the purpose of having a MUTABLE string where a VARIETY of OPERATIONS can be performed.

System.String is immutable; System.StringBuilder was designed with the purpose of having a mutable string where a variety of operations can be performed.

Yes,

just place a COLON, and then keyword BASE (parameter LIST to invoke the appropriate constructor) in the OVERLOADED constructor definition INSIDE the inherited class.

Yes,

just place a colon, and then keyword base (parameter list to invoke the appropriate constructor) in the overloaded constructor definition inside the inherited class.

DIFFERENT parameter DATA types, different number of PARAMETERS, different order of parameters.

Different parameter data types, different number of parameters, different order of parameters.

In the INTERFACE all METHODS must be abstract; in the abstract CLASS some methods can be concrete. In the interface no accessibility modifiers are ALLOWED, which is ok in abstract classes.

In the interface all methods must be abstract; in the abstract class some methods can be concrete. In the interface no accessibility modifiers are allowed, which is ok in abstract classes.

It’s up to you to implement the method INSIDE your own class, so implementation is left entirely up to you. This might cause a PROBLEM on a higher-level scale if similarly named METHODS from DIFFERENT interfaces expect different DATA.

It’s up to you to implement the method inside your own class, so implementation is left entirely up to you. This might cause a problem on a higher-level scale if similarly named methods from different interfaces expect different data.

YES,

Yes,

They all MUST be PUBLIC. Therefore, to prevent you from GETTING the false impression that you have any FREEDOM of choice, you are not allowed to specify any accessibility, its public by default.

They all must be public. Therefore, to prevent you from getting the false impression that you have any freedom of choice, you are not allowed to specify any accessibility, its public by default.

It is an ABSTRACT class with public abstract METHODS all of which must be implemented in the INHERITED CLASSES.

It is an abstract class with public abstract methods all of which must be implemented in the inherited classes.

When at least ONE of the METHODS in the CLASS is ABSTRACT. When the class itself is inherited from an abstract class, but not all base abstract methods have been over-ridden.

When at least one of the methods in the class is abstract. When the class itself is inherited from an abstract class, but not all base abstract methods have been over-ridden.

A class that cannot be instantiated. A concept in C++ known as PURE virtual method. A class that must be inherited and have the METHODS over-ridden. Essentially, it is a BLUEPRINT for a class without any implementation.

A class that cannot be instantiated. A concept in C++ known as pure virtual method. A class that must be inherited and have the methods over-ridden. Essentially, it is a blueprint for a class without any implementation.

Yes,

just LEAVE the CLASS public and MAKE the method sealed.

Yes,

just leave the class public and make the method sealed.

YES,

that’s what KEYWORD sealed in the class definition is for. The DEVELOPER TRYING to derive from your class will get a message: cannot inherit from Sealed class WhateverBaseClassName. It’s the same CONCEPT as final class in Java.

Yes,

that’s what keyword sealed in the class definition is for. The developer trying to derive from your class will get a message: cannot inherit from Sealed class WhateverBaseClassName. It’s the same concept as final class in Java.

No,

moreover, you cannot ACCESS PRIVATE methods in INHERITED classes, have to be protected in the base class to allow any sort of access.

No,

moreover, you cannot access private methods in inherited classes, have to be protected in the base class to allow any sort of access.

No,

you can’t, the signature of the virtual method MUST REMAIN the same, only the keyword virtual is changed to keyword override.

No,

you can’t, the signature of the virtual method must remain the same, only the keyword virtual is changed to keyword override.

The METHOD can be OVERRIDDEN.

The method can be overridden.

When overriding, you CHANGE the method BEHAVIOR for a derived CLASS. Overloading simply INVOLVES having a method with the same name WITHIN the class.

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

System.Object.

System.Object.

Two.

Once you write at LEAST ONE CONSTRUCTOR, C# CANCELS the freebie constructor, and now you have to write one yourself, even if there is no implementation in it.

Two.

Once you write at least one constructor, C# cancels the freebie constructor, and now you have to write one yourself, even if there is no implementation in it.

It is available to derived classes and classes within the same Assembly (and NATURALLY from the base class it is DECLARED in).

It is available to derived classes and classes within the same Assembly (and naturally from the base class it is declared in).

Yes,

but they are not accessible, so LOOKING at it you can honestly SAY that they are not INHERITED. But they are.

Yes,

but they are not accessible, so looking at it you can honestly say that they are not inherited. But they are.

CLASSES in the same NAMESPACE.

Classes in the same namespace.

No,

USE INTERFACES INSTEAD.

No,

use interfaces instead.

Place a COLON and then the NAME of the base class. Notice that it’s DOUBLE colon in C++.

Place a colon and then the name of the base class. Notice that it’s double colon in C++.

Value, and its DATATYPE DEPENDS on WHATEVER variable we are CHANGING.

Value, and its datatype depends on whatever variable we are changing.

INTEGER,STRING and DATE.

Integer,String and Date.

It is the Attributesproperty, the ADD FUNCTION INSIDE that PROPERTY. e.g. btnSubmit.Attributes.Add ("onMouse Over" ,"someClientCode();")

It is the Attributesproperty, the Add function inside that property. e.g. btnSubmit.Attributes.Add ("onMouse Over" ,"someClientCode();")

A set of server controls included with ASP.NET that TEST user INPUT in HTML and Web server controls for programmer-defined REQUIREMENTS. VALIDATION controls perform input checking in server CODE. If the user is working with a browser that supports DHTML, the validation controls can also perform validation using client script.

A set of server controls included with ASP.NET that test user input in HTML and Web server controls for programmer-defined requirements. Validation controls perform input checking in server code. If the user is working with a browser that supports DHTML, the validation controls can also perform validation using client script.

Custom controls: A control authored by a USER or a third-party software vendor that does not BELONG to the .NET Framework class library. This is a generic TERM that INCLUDES user controls. A custom server control is used in Web Forms (ASP.NET pages). A custom client control is used in Windows Forms applications.

User Controls: In ASP.NET: A user-authored server control that enables an ASP.NET page to be re-used as a server control. An ASP.NET user control is authored declaratively and persisted as a TEXT file with an .ascx extension. The ASP.NET page framework compiles a user control on the fly to a class that derives from the System.Web.UI.UserControl class.

Custom controls: A control authored by a user or a third-party software vendor that does not belong to the .NET Framework class library. This is a generic term that includes user controls. A custom server control is used in Web Forms (ASP.NET pages). A custom client control is used in Windows Forms applications.

User Controls: In ASP.NET: A user-authored server control that enables an ASP.NET page to be re-used as a server control. An ASP.NET user control is authored declaratively and persisted as a text file with an .ascx extension. The ASP.NET page framework compiles a user control on the fly to a class that derives from the System.Web.UI.UserControl class.

Value TYPES uses STACK to STORE the DATA where as the later uses the Heap to store the data.

Value Types uses Stack to store the data where as the later uses the Heap to store the data.

MSIL is the Microsoft INTERMEDIATE LANGUAGE. All .NET compatible languages will get CONVERTED to MSIL. MSIL ALSO allows the .NET Framework to JIT compile the ASSEMBLY on the installed computer.

MSIL is the Microsoft Intermediate Language. All .NET compatible languages will get converted to MSIL. MSIL also allows the .NET Framework to JIT compile the assembly on the installed computer.

Response.OUTPUT.WRITE() ALLOWS you to write FORMATTED output.

Response.Output.Write() allows you to write formatted output.

Delay signing allows you to place a SHARED assembly in the GAC by signing the assembly with just the public key. This allows the assembly to be SIGNED with the private key at a later stage, when the development PROCESS is complete and the component or assembly is ready to be deployed. This process enables developers to work with shared ASSEMBLIES as if they were strongly named, and it secures the private key of the signature from being accessed at different stages of development.

Delay signing allows you to place a shared assembly in the GAC by signing the assembly with just the public key. This allows the assembly to be signed with the private key at a later stage, when the development process is complete and the component or assembly is ready to be deployed. This process enables developers to work with shared assemblies as if they were strongly named, and it secures the private key of the signature from being accessed at different stages of development.

JIT (Just - In - Time) is a compiler which converts MSIL CODE to native code, Because the common language runtime supplies a JIT compiler for each supported CPU architecture, developers can write a set of MSIL that can be JIT-compiled and run on computers with different ARCHITECTURES. However, your managed code will run only on a specific operating system if it calls platform-specific native APIs, or a platform-specific class library.

JIT compilation takes into account the fact that some code might never get CALLED during execution. Rather than USING time and memory to convert all the MSIL in a portable executable (PE) file to native code, it converts the MSIL as needed during execution and stores the resulting native code so that it is accessible for subsequent calls. The LOADER creates and attaches a stub to each of a type's methods when the type is loaded. On the initial call to the method, the stub passes control to the JIT compiler, which converts the MSIL for that method into native code and modifies the stub to direct execution to the location of the native code. Subsequent calls of the JIT-compiled method proceed directly to the native code that was previously generated, reducing the time it takes to JIT-compile and run the code.

JIT (Just - In - Time) is a compiler which converts MSIL code to native code, Because the common language runtime supplies a JIT compiler for each supported CPU architecture, developers can write a set of MSIL that can be JIT-compiled and run on computers with different architectures. However, your managed code will run only on a specific operating system if it calls platform-specific native APIs, or a platform-specific class library.

JIT compilation takes into account the fact that some code might never get called during execution. Rather than using time and memory to convert all the MSIL in a portable executable (PE) file to native code, it converts the MSIL as needed during execution and stores the resulting native code so that it is accessible for subsequent calls. The loader creates and attaches a stub to each of a type's methods when the type is loaded. On the initial call to the method, the stub passes control to the JIT compiler, which converts the MSIL for that method into native code and modifies the stub to direct execution to the location of the native code. Subsequent calls of the JIT-compiled method proceed directly to the native code that was previously generated, reducing the time it takes to JIT-compile and run the code.

It's certainly an issue that affects component design. If you have objects that maintain EXPENSIVE or scarce resources (e.g. database locks), you NEED to provide some way for the client to tell the object to release the resource when it is DONE. Microsoft recommend that you provide a method called Dispose() for this purpose. However, this causes problems for DISTRIBUTED objects - in a distributed system who calls the Dispose() method? Some form of reference-counting or ownership-management mechanism is needed to handle distributed objects - unfortunately the runtime offers no help with this.

It's certainly an issue that affects component design. If you have objects that maintain expensive or scarce resources (e.g. database locks), you need to provide some way for the client to tell the object to release the resource when it is done. Microsoft recommend that you provide a method called Dispose() for this purpose. However, this causes problems for distributed objects - in a distributed system who calls the Dispose() method? Some form of reference-counting or ownership-management mechanism is needed to handle distributed objects - unfortunately the runtime offers no help with this.

Because of the GARBAGE collection algorithm. The .NET garbage collector works by periodically running through a list of all the objects that are currently being referenced by an application. All the objects that it doesn't find during this search are ready to be DESTROYED and the memory reclaimed. The implication of this algorithm is that the runtime doesn't get notified immediately when the FINAL reference on an object goes away - it only finds out during the next sweep of the heap.

Futhermore, this type of algorithm works best by performing the garbage collection sweep as rarely as POSSIBLE. Normally heap exhaustion is the trigger for a collection sweep.

Because of the garbage collection algorithm. The .NET garbage collector works by periodically running through a list of all the objects that are currently being referenced by an application. All the objects that it doesn't find during this search are ready to be destroyed and the memory reclaimed. The implication of this algorithm is that the runtime doesn't get notified immediately when the final reference on an object goes away - it only finds out during the next sweep of the heap.

Futhermore, this type of algorithm works best by performing the garbage collection sweep as rarely as possible. Normally heap exhaustion is the trigger for a collection sweep.

Garbage COLLECTION is a system whereby a run-time COMPONENT takes responsibility for managing the lifetime of objects and the heap MEMORY that they occupy. This concept is not new to .NET - JAVA and many other languages/runtimes have used garbage collection for some time.

Garbage collection is a system whereby a run-time component takes responsibility for managing the lifetime of objects and the heap memory that they occupy. This concept is not new to .NET - Java and many other languages/runtimes have used garbage collection for some time.

Each assembly has a version NUMBER called the compatibility version. Also each reference to an assembly (from ANOTHER assembly) includes both the name and version of the REFERENCED assembly.The version number has FOUR numeric parts (e.g. 5.5.2.33). Assemblies with either of the first two parts different are normally viewed as incompatible. If the first two parts are the same, but the third is different, the assemblies are deemed as 'maybe compatible'. If only the fourth PART is different, the assemblies are deemed compatible. However, this is just the default guideline - it is the version policy that decides to what extent these rules are enforced. The version policy can be specified via the application configuration file.

Each assembly has a version number called the compatibility version. Also each reference to an assembly (from another assembly) includes both the name and version of the referenced assembly.The version number has four numeric parts (e.g. 5.5.2.33). Assemblies with either of the first two parts different are normally viewed as incompatible. If the first two parts are the same, but the third is different, the assemblies are deemed as 'maybe compatible'. If only the fourth part is different, the assemblies are deemed compatible. However, this is just the default guideline - it is the version policy that decides to what extent these rules are enforced. The version policy can be specified via the application configuration file.

By searching directory paths. There are several FACTORS which can affect the path (such as the AppDomain host, and APPLICATION CONFIGURATION files), but for private assemblies the search path is normally the application's directory and its sub-directories. For SHARED assemblies, the search path is normally same as the private assembly path PLUS the shared assembly cache.

By searching directory paths. There are several factors which can affect the path (such as the AppDomain host, and application configuration files), but for private assemblies the search path is normally the application's directory and its sub-directories. For shared assemblies, the search path is normally same as the private assembly path plus the shared assembly cache.

Metadata and MANIFEST forms an integral part of an assembly( dll / exe ) in .net framework . Out of which Metadata is a mandatory component, which as the name suggests gives the details about various components of IL code viz : Methods, properties, fields, class etc.

Essentially Metadata MAINTAINS details in FORM of tables like Methods Metadata tables , Properties Metadata tables, which maintains the list of given type and other details like access specifier , return type etc.

Now Manifest is a part of metadata only, fully called as “manifest metadata tables” , it contains the details of the references needed by the assembly of any other EXTERNAL assembly / type , it could be a custom assembly or standard SYSTEM namespace.

Now for an assembly that can independently exists and used in the .Net world both the things ( Metadata with Manifest ) are mandatory , so that it can be fully described assembly and can be ported anywhere without any system dependency . Essentially .Net framework can read all assembly related information from assembly itself at runtime.

But for .Net modules , that can’t be used independently , until they are being packaged as a part of an assembly , they don’t contain Manifest but their complete structure is defined by their respective metadata.

Metadata and Manifest forms an integral part of an assembly( dll / exe ) in .net framework . Out of which Metadata is a mandatory component, which as the name suggests gives the details about various components of IL code viz : Methods, properties, fields, class etc.

Essentially Metadata maintains details in form of tables like Methods Metadata tables , Properties Metadata tables, which maintains the list of given type and other details like access specifier , return type etc.

Now Manifest is a part of metadata only, fully called as “manifest metadata tables” , it contains the details of the references needed by the assembly of any other external assembly / type , it could be a custom assembly or standard System namespace.

Now for an assembly that can independently exists and used in the .Net world both the things ( Metadata with Manifest ) are mandatory , so that it can be fully described assembly and can be ported anywhere without any system dependency . Essentially .Net framework can read all assembly related information from assembly itself at runtime.

But for .Net modules , that can’t be used independently , until they are being packaged as a part of an assembly , they don’t contain Manifest but their complete structure is defined by their respective metadata.

These all are access modifier and they governs the access LEVEL. They can be applied to class, methods, FIELDS.

Public: Allows class, methods, fields to be accessible from anywhere i.e. within and OUTSIDE an assembly.

Private: When applied to field and method allows to be accessible within a class.

Protected: Similar to private but can be accessed by members of derived class also.

INTERNAL: They are public within the assembly i.e. they can be accessed by anyone within an assembly but outside assembly they are not VISIBLE.

These all are access modifier and they governs the access level. They can be applied to class, methods, fields.

Public: Allows class, methods, fields to be accessible from anywhere i.e. within and outside an assembly.

Private: When applied to field and method allows to be accessible within a class.

Protected: Similar to private but can be accessed by members of derived class also.

Internal: They are public within the assembly i.e. they can be accessed by anyone within an assembly but outside assembly they are not visible.

This three along with name of the assembly provide a strong name or FULLY QUALIFIED name to the assembly. When a assembly is referenced with all three.

PublicKeyToken: Each assembly can have a public key embedded in its MANIFEST that identifies the developer. This ensures that once the assembly ships, no one can modify the code or other resources contained in the assembly.

Culture: Specifies which culture the assembly supports.

VERSION: The version number of the assembly.It is of the following form major,minor,build,revision.

This three along with name of the assembly provide a strong name or fully qualified name to the assembly. When a assembly is referenced with all three.

PublicKeyToken: Each assembly can have a public key embedded in its manifest that identifies the developer. This ensures that once the assembly ships, no one can modify the code or other resources contained in the assembly.

Culture: Specifies which culture the assembly supports.

Version: The version number of the assembly.It is of the following form major,minor,build,revision.

Strong names are used to enable the stricter naming requirements associated with shared assemblies. These strong names are created by a .NET utility – sn.exe

Strong names have three goals:

•  Name uniqueness. Shared assemblies must have names that are globally unique.
• Prevent name spoofing. Developers don't want someone else releasing a subsequent version of one of your assemblies and falsely claim it came from you, either by accident or intentionally.
• Provide identity on reference. When resolving a reference to an assembly, strong names are used to guarantee the assembly that is loaded came from the expected publisher.

Strong names are IMPLEMENTED using standard public KEY cryptography. In general, the process works as follows: The author of an assembly generates a key pair (or uses an existing one), signs the file containing the manifest with the private key, and MAKES the public key available to callers. When references are made to the assembly, the caller records the public key corresponding to the private key used to generate the strong name.

Weak named assemblies are not suitable to be added in GAC and shared. It is ESSENTIAL for an assembly to be strong named.

Strong naming prevents tampering and enables assemblies to be placed in the GAC alongside other assemblies of the same name.

Strong names are used to enable the stricter naming requirements associated with shared assemblies. These strong names are created by a .NET utility – sn.exe

Strong names have three goals:

Strong names are implemented using standard public key cryptography. In general, the process works as follows: The author of an assembly generates a key pair (or uses an existing one), signs the file containing the manifest with the private key, and makes the public key available to callers. When references are made to the assembly, the caller records the public key corresponding to the private key used to generate the strong name.

Weak named assemblies are not suitable to be added in GAC and shared. It is essential for an assembly to be strong named.

Strong naming prevents tampering and enables assemblies to be placed in the GAC alongside other assemblies of the same name.

An ASSEMBLY QUALIFIED name isn't the filename of the assembly; it's the internal name of the assembly combined with the assembly version, culture, and public KEY, thus making it UNIQUE.

e.g. (""System.Xml.XmlDocument, System.Xml, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c5 61934e089"").

An assembly qualified name isn't the filename of the assembly; it's the internal name of the assembly combined with the assembly version, culture, and public key, thus making it unique.

e.g. (""System.Xml.XmlDocument, System.Xml, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c5 61934e089"").

Each computer where the common language runtime is installed has a machine-wide code cache called the global assembly cache. The global assembly cache stores assemblies that are to be shared by several applications on the computer. This area is typically the FOLDER under windows or winint in the machine.

All the assemblies that need to be shared across applications need to be done through the Global assembly Cache only. However it is not necessary to install assemblies into the global assembly cache to make them accessible to COM interop or unmanaged code.

There are several ways to deploy an assembly into the global assembly cache:

• Use an installer designed to work with the global assembly cache. This is the preferred option for installing assemblies into the global assembly cache.
•  Use a developer tool called the Global Assembly Cache tool (Gacutil.exe), provided by the .NET Framework SDK.
• Use Windows Explorer to drag assemblies into the cache.
• GAC solves the problem of DLL Hell and DLL versioning. Unlike earlier situations, GAC can hold two assemblies of the same name but DIFFERENT version.

This ensures that the applications which access a particular assembly CONTINUE to access the same assembly even if another version of that assembly is installed on that machine.

Each computer where the common language runtime is installed has a machine-wide code cache called the global assembly cache. The global assembly cache stores assemblies that are to be shared by several applications on the computer. This area is typically the folder under windows or winint in the machine.

All the assemblies that need to be shared across applications need to be done through the Global assembly Cache only. However it is not necessary to install assemblies into the global assembly cache to make them accessible to COM interop or unmanaged code.

There are several ways to deploy an assembly into the global assembly cache:

This ensures that the applications which access a particular assembly continue to access the same assembly even if another version of that assembly is installed on that machine.