VB.Net Interview Questions

• The classes that can be declared within another class's scope are known as nested classes. These classes are included in the contained class's scope and are available inside that class's scope.
• A value type containing a set of constants given to the set of the list is known as an Enumerator or Enum. When more than one number needs to be defined, enumeration is utilised.

Some benefits of using VB.NET are as follows:

• VB.NET is a modern, general-purpose language.
• It is an object-oriented programming language.
• For a newbie, VB.NET is quite simple to learn.
• It is a structure-oriented programming language.
• VB.NET can be built on a number of different platforms.
• Conditional Compilation is supported by VB.NET.
• VB.NET has a Standard Library and Automatic Garbage Collection.
• It has Property and Event support.
• VB.NET aids in the management of delegates and events.
• Generics, Indexers, and Simple Multithreading are all supported.

An assembly manifest is a text file in the.NET Framework that contains metadata about the code in a CLI assembly. It describes the components' relationships and dependencies, as well as the assembly's versioning information, scope information, and security permissions. The Manifest file type can be saved as a PE file type. As a Manifest, you can save the Assembly Name, Version, Culture, and key token.

Globalization is essentially the process of adapting your application to different cultures. You must recognise that your application's users may speak a different language than you and that their language, in addition to being a different language, follows different rules. Some languages, for example, should be displayed right to left, whereas others should be displayed left to right. You must now consider not just the various languages, but also the various currencies, date and time settings, and the various colours associated with various civilizations. With globalisation, you can make your software accessible to people from all over the world, regardless of their language.

Keywords that are used to specify the declared accessibility of a member or a type is known as class access modifiers. The various types of class access modifiers are as follows:

• Public
• Private
• Protected
• Protected Internal
• Internal

An array of arrays array named scores of Integers is demonstrated in the code below.  is called a Jagged array. Declaring a jagge:

Dim marks As Integer()() = New Integer(10)(){}

The example code snippet below shows how to use a jagged array:

Module demoArray
  Sub Main()
     ' making one jagged array of 3 arrays of integers
     Dim arr As Integer()() = New Integer(2)() {}
     arr(0) = New Integer() {5, 6}
     arr(1) = New Integer() {15, 10}
     arr(2) = New Integer() {32, 60}
     Dim a, b As Integer
     ' printing the value of every array element 
     
     For a = 0 To 3
        For b = 0 To 1
           Console.WriteLine("arr[{0},{1}] = {2}", a, b, arr(a)(b))
        Next b
     Next a
     Console.ReadKey()
  End Sub
End Module

The output of the above code snippet will be as follows:

arr[0][0]: 5
arr[0][1]: 6
arr[1][0]: 15
arr[1][1]: 10
arr[2][0]: 32
arr[2][1]: 60 

The ReDim statement is used to resize or enlarge a dynamic array that has already been formally declared with empty parenthesis using a Private, Public, or Dim declaration (without dimension subscripts). To alter the number of elements and dimensions in an array, use the ReDim statement repeatedly. However, unless the array is included in a Variant, one can't define an array of one data type and then use ReDim to transform it to another data type. If the array is stored in a Variant, the type of the items can be changed with an As type clause, unless the Preserve keyword is used, in which case no data type changes are allowed.

An example of the usage of the ReDim keyword is given below:

Dim DemoArray() As Integer ' Declaring a dynamic array. 
Redim DemoArray(10) ' Allocating 10 elements. 
For J = 1 To 10 ' Looping for 10 times. 
DemoArray(J) = J ' Initializing the DemoArray. 
Next J

The ReDim statement is used in the above example to allocate and reallocate storage space for dynamic array variables in this example. The Option Base is assumed to be 1. The ReDim keyword is only applicable to arrays and is used to modify the size of one or more dimensions of an array that has already been declared. When needed, Redim can free up or add elements to an array.

The constructor is used along with the NEW keyword. Its usage can be as that of a modifier or an operator. The NEW keyword hides inherited members from base class members when used as a modifier. It produces objects for invoking constructors when used as an operator. The NEW keyword creates a new object instance, provides a constructor constraint on a type argument, or designates another function as a class constructor. A New clause can be used in either a declaration or an assignment statement. When you run the statement, it calls the proper constructor of the specified class, passing any parameters you have given it. 

An example of the usage of the NEW keyword is given below:

Dim teacher1 As New Teacher()

An access specifier that will be displayed in a specific assembly, that is, in a DLL (Dynamic Link Library) file, is the INTERNAL keyword. This is visible throughout the assembly as a unique binary component.

The System.object class is the base class of VB.NET.

In general, .Net allows any data type to be implicitly converted. 

• Option Strict is used to prevent the leakage of data during the conversions of data type, and it guarantees the compile-time notification of certain forms of conversions. 
• Option Explicit is a keyword in a file that is used to exclusively declare each and every variable using declare keywords such as Dim, Private, Public, and Protected. An error occurs at compile time in the event of an undeclared variable name persisting.

Assemblies are a component of .NET applications and are considered to be the main part of all .NET apps. They can be either a DLL (Dynamic Link Library) or an executable file. The two forms of assemblies are as follows:

• Private - Private assemblies are those that are only utilised by one application and are kept in the application's directory.
• Public - Public assemblies, also known as shared assemblies, are saved in the Global Assembly Cache (GAC), which can be accessed by several programs.

Strong Name is nothing but a feature of .Net whose usage lies in uniquely identifying shared assemblies. A strong name is a solution to the problem of several objects with the same name being created, and it may be assigned using Sn.exe.

• Metadata: Metadata is defined as "data on the body of the data" and can be found in library catalogues. In practice, metadata's usage comes in evaluating database data, although it can also be utilised for other purposes.
• Namespace: In the.NET language, namespaces are nothing but an organised manner of representing classes, structures, and interfaces. All .NET Languages have access to namespaces, which are hierarchically organised indexes of a class library.
• JIT: It is an acronym for Just in Time compiler, which is a component of the runtime execution environment. JIT is divided into three categories:
  • Normal JIT: Normal JITs compile called functions or procedures at runtime and compile them for the first time when they are invoked.
  • Pre-JIT: Pre JITs compile an application before it is deployed.
  • Econo-JIT: Econo JITs compile called functions and procedures at runtime.

The System.Data namespace is used to access and manage data from the required data source. This namespace deals only with the data from the specified database.

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.

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.

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

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 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.

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.

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.

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.

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.

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.

No, the .tostring method cannot handle NULL values. Instead of it, we can use Convert .tostring method to handle NULL values.

• 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.

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.

Conclusion:

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