Explore topic-wise InterviewSolutions in Current Affairs.

The garbage collector in VB.NET regulates memory allocation and release for your application. When you create a new OBJECT, the managed heap is used to allocate memory for it via the common language RUNTIME. The runtime continues to allocate space for new objects as long as address space in the managed heap is available. Memory, on the other hand, is finite. In order to liberate some memory, the garbage collector must eventually complete a collection. Based on the allocations being made, the garbage collector's optimising engine calculates the optimal moment to do a collection. When the garbage collector does a collection, it searches the managed heap for objects that are no longer in use by the application and executes the appropriate procedures to free up their memory. The garbage collector (GC) is an automatic memory manager in the Common Language Runtime (CLR). The garbage collector is in charge of managing an application's memory allocation and release. This means that you do not have to create code to handle memory management duties if you are dealing with managed PROGRAMS. Automatic memory management can solve problems like forgetting to free an item, resulting in a memory leak, or trying to access memory for an object that has already been freed.

A few advantages of garbage collection are as follows:

• It eliminates the need for developers to manually release memory.
• Objects are efficiently allocated on the controlled heap.
• Objects that are no longer in use are reclaimed, their memory is cleared, and the memory is made available for future allocations. Managed objects come with clean content out of the box, so their builders don't have to worry about filling in every data field.
• Provides memory safety by ensuring that an object cannot use memory assigned to another object for its own purposes.

In this article, we aim to make our readers aware of what VB.NET is and what are the various features offered by this framework. It is an extremely important topic from the point of view of a technical interview. We have also discussed various questions on VB.NET with difficulty ranging from easy to hard as asked in any VB.NET interview. We hope that our readers GET a good insight on VB.NET using this article and ace their interview. 

Additional Useful Resources:

• C# Interview Questions
• ASP.NET Interview Questions
• .NET Interview Questions
• ADO.NET Interview Questions
• Web API Interview Questions

• A LIGHTWEIGHT process controlled by the .NET runtime can be thought of as an application DOMAIN. Hosts such as windows SHELL, asp.net, and many more build application domains. 
• For example, when you execute a .net application from the COMMAND line, the host is the shell. For each application, the shell ESTABLISHES a new application domain.

No, the .TOSTRING method cannot HANDLE NULL values. INSTEAD of it, we can USE Convert .tostring method to handle NULL values.

Unmanaged code is code that the operating system directly executes. It has always focused on the architecture of the processor and is dependent on the architecture of the computer. On compilation, this code tends to choose a particular architecture and execute on that platform. LOOSELY speaking, if you wish to run similar codes on a different architecture, you must recompile it in accordance with that architecture. The compilation is always done to the native code, which is architecture-specific.

The developer MANAGES to allot space, security, type safety, and other aspects of unmanaged programming. As a result, various memory-related issues arise, such as space overflow, memory leakage, override of pointers, and so on. Unmanaged code executable files are usually binary images, x86 code that is loaded directly into memory. Unmanaged code is used in applications created in VB 6.0, C, C++, and other languages. The following GRAPHIC depicts the running of an unmanaged code:

Some of the benefits of Unmanaged Code are as follows:

• Unmanaged code gives the programmer low-level access.
• It can also allow us to access the hardware directly.
• It enables the user to SKIP certain of the managed code framework's parameters and restrictions.

Some of the drawbacks of Unmanaged Code are as follows:

• The application is not secure as a result of it.
• Memory-related difficulties, such as memory space overflow, arise as a result of access to memory allocation.
• The programmer is also in charge of handling ERRORS and exceptions.
• It is not concerned with rubbish collection.

Some of the advantages of MANAGED Code in VB.NET are as follows:

• It implements trash collection on its own.
• It improves the application's security by AUTOMATICALLY checking memory spaces for preventing buffer overflow when using the runtime environment.
• It also checks references, which determines whether or not the reference points to a genuine object and whether or not they are duplicates.
• It also includes type checking at runtime and dynamic type checking.

The fundamental drawback of managed languages is that we can't allot memory on our own, and we can't ACCESS the architecture of the Central Processing Unit or CPU at a basic level. C#, Visual Basic, F#, and other high-level languages that may be executed on top of .NET are examples of managed code. You do not RECEIVE machine code when you COMPILE code written in those languages with their respective compilers. The runtime then compiles and executes the Intermediate Language code. The only exception to this rule is C ++, which may generate native, unmanaged binaries for Windows. Runtime engines include Java, Visual Basic, and the.NET Common Language Runtime (CLR). A DBMS may also have a runtime engine for the programming language it supports.

Managed Code is a type of code that is created to use the functionalities of a controlled runtime environment, such as the CLR (Common Language Runtime) in the .NET Framework. Instead of being directly performed by the operating system, it is always implemented by the controlled runtime environment. The controlled runtime environment provides a lot of features, for instance, garbage collection, handling of exceptions, type CHECKING, bounds checking, and other services to programs without requiring the intervention of the user. It also allocated MEMORY to the code, type safety, and other features. Applications built-in languages such as Java, VB.Net, and many others are always aimed at runtime environment services to manage execution, and programs CODED in these languages are referred to as managed code.

In the scenario of the .NET Framework, the compilation of the managed code is always done by the compiler in MSIL (Microsoft INTERMEDIATE Language) before creating an executable. The CLR's Just In Time (JIT) Compiler translates the intermediary language into native code that is particular to the architecture lying beneath when the programmer runs the executable. This procedure is running in a managed runtime execution environment, and the environment is in charge of the code's FUNCTIONALITY. The managed code is executed as indicated in the image below, with the source code coded in any .NET Framework language.

Because managed code is compiled into an intermediate language, the JIT compiler turns this intermediate language into architecture-specific instructions, providing platform independence.

Common TYPE System (CTS): The data types that managed code can use are described by the Common Type System (CTS). In the runtime, CTS describes how these types are declared, utilised, and managed. Cross-language integration, type safety, and high-performance code execution are all made easier using it. You can utilise the CTS rules to create your own classes and values. ALTERNATIVELY, we can comprehend SOMETHING like this that the data type is dealt with by CTS. So we have a number of languages, each of which has its own data type. While one language's data type may be incomprehensible to other languages, the .NET Framework language can comprehend all data types. Integer data types are available in both C# and VB.NET. As a result, a variable specified as an int in C# and Integer in VB.NET utilises the same structure Int32 from CTS after compilation as shown in the figure below. All of the structures and classes in CTS are shared by all.NET languages, and their PURPOSE is to support language NET's independence. As a result, it is known as CTS.

Common Language Specification(CLS): CLS is a subset of CTS and stands for Common Language Specification. It specifies a set of rules and constraints that must be followed by any language that runs on the .NET framework. CLS Compliant languages are those that follow this set of rules. CLS facilitates cross-language integration, or interoperability, in basic terms. As an example, if we are talking about C# and VB.NET, every statement in C# must end with a semicolon. Although it is often known as a statement Terminator, that is, each statement in VB.NET should not conclude with a semicolon (;). An explanation of the mentioned example is that while the syntax rules change from language to language, CLR can understand all of them because, in .NET, each language is transformed into MSIL (Microsoft Intermediate Language) code after compilation, and MSIL code is CLR's language specification.

CLR stands for Common Language Runtime, and it is the brain behind the .NET framework. It is the RESPONSIBILITY of the runtime to ensure that the program's code is EXECUTED correctly. The following is taken care of by CLR:

• Verification of Garbage Collection Codes.
• IL (Intermediate Language) for Code ACCESS Security.

The GLOBAL ASSEMBLY Cache (GLC) is USED to store shared .NET assemblies. The following criteria make use of it:

• If there are any unique security needs for .Net assemblies.
• If a .Net application has to share data with other PROGRAMS.

In the garbage collector, there are THREE generations:

• Generation 0: It represents a brand new object that has never been marked for COLLECTION.
• Generation 1: It identifies an object that has been DESIGNATED as a collection but has not yet been removed.
• Generation 2: This indicates an object that has been SWEPT by the Garbage Collector more than once.

The process of getting credentials from users and VALIDATING their authenticity is known as authentication. The process of granting access to authenticated resources is known as authorization. The authorization follows Authentication and authorization can be done in various ways, for instance, users can be authorised to have various KINDS of access to the application such as READ ONLY access, Write Access, Delete Access, etc. Both application architects and developers are concerned about authentication. Applications that store SENSITIVE data must be safeguarded against hostile assaults and competitors attempting to steal data or intellectual property. When building a SECURITY model for your application, keep in mind the business needs for authentication as well as the impact that a security model choice can have on performance, scalability, and deployment.

Authentication can be divided into various categories:

• Windows Authentication 
• PASSPORT Authentication 
• Form Authentication
• Anonymous Authentication
• Basic Authentication
• Digest Authentication
• Port Authentication
• Certificate Authentication
• Using Cookies

A DELEGATE is a TYPE of object that can be used to refer to a method. When you assign a delegate to a method, it functions precisely LIKE that method. Delegates are objects that serve as placeholders for methods. Because they are comparable to function pointers used in other programming languages, they are also referred to as type-safe function pointers. Visual Basic delegates, unlike function pointers, are a reference type BASED on the class System.Delegate.

Garbage COLLECTION in VB.NET, often known as automatic MEMORY management, is a technique for discarding dynamically allocated memory automatically. Garbage collection is handled by a garbage collector, who will recycle memory if it is determined that it will be used in the future.

• The garbage collector invokes the Finalize() method, which aids in the cleanup of unmanaged resources. Other resources, such as window HANDLES and database connections, are managed through the iDisposable interface.
• To explicitly RELEASE unused resources, the Dispose() method is handled by the IDisposable interface. Even if other references to the object are alive, Dispose() method can be called.