Adaface .NET Core ready-to-go tests are designed by experts to evaluate on-the-job skills

Customize Adaface tests to assess multiple skills in a single assessment

🧐 Test 🔧 Sample Topics 💪 Useful for hiring
C# .NET Senior Developer Test
Arrays
Loops
Inheritance
Functions
Razor View
Controler
Entity Framework
Segments
C#.Net Web API
Routing
Senior Level C# Programmer
C# Senior Developer
Asp.Net MVC Online Test
Authentication Filter
Search and Sort
Scaffolding
Creating new string
Validations
Lazy Loading
Serialization
Query that returns entities
Metadata classes
.Net MVC Developer
ASP.Net MVC Designer
C# .NET Junior Developer Test
Class
Method
Object
Encapsulation
Inheritance
Constructors
C# .Net Junior Developer
C# Software Developers with 0 to 2 years of experience
C# Online test
Null-Conditional Operator
Static Using Syntax
Expression Bodied Function & Property
Boolean Comparison Operator
Increment Operators
Regular Expression
Disposal and Garbage Collection
C# Developer
C# Programmer
C# ASP.NET MVC Test
Razor View
Controller
Entity Framework
Segments
Routing
Configuration and Deployment
Bundling And Minification
Dynamic and Strongly typed View
Constraint
ASP .NET MVC Developer ( 2 - 4 yrs of exp.)
Full Stack .NET Developer
Java Online Test
Core Java
Data Types
Threads
Servlets
OOPs
classes
Core Java Developer
Core Java Programmer
Backend Developer
Web Developer
JavaScript Online Test
Control Flow
Error handling
Data Models
Asynchronity
DOM Manipulation
Node
Functional Approach
Object Oriented Approach
Prototype
Class
Scope
JavaScript Developer
JavaScript Programmer
Backend Developer
Frontend Developer
NodeJS Developer
React Developer
Angular Developer
HTML/ CSS Online Test
attributes
various functions
elements
tags
encoding
logical document sections
HTML5 Developer
Web Designer
Front end developer
Full Stack developer
SQL Online Test
Relational Keys
Select Queries
Joins
Data Modelling
Fact and Dimension Table Types
Star Schema
Snow Flake Schema
SQL Developer
Data Analyst
Data Scientist
DevOps Engineer
Database Administrator
MySQL Online Test
Joins
Queries
Grouping
Aggregate Functions
HAVING Clause
Functions
Keys
Constraints
Indexes
MySQL Developer
Data Analyst
Database Administrator
Database Administrator
SQL Developer
MS SQL Test (Advance)
Transact SQL Statement
Stored Procedure
SQL Server 2008
Truncate Statements
triggers
SQL Server Developer
MS SQL Server developer
PostgreSQL Online Test
PostgreSQL Database Administrator
PostgreSQL Database Developer
ASP.Net Test (4.5 Framework)
Custom Error Page
Content Updates
Content Uploading
Grid View Control
Fields and Tooltip
Custom Control
Field Validation
ASP .Net Developer
Software Developer- ASP.Net
C# .NET Architect Test
Razor View
Controller
Entity Framework
Segments
C#.Net Web API
Routing
Configuration and Deployment
Bundling And Minification
Dynamic and Strongly typed View
Constraint
C# .NET Architect
IT Solution Architect
CSS3 Test (Cascading Style Sheets)
Descendant Selectors
Visited Hyperlinks
Pseudo-Class Property
CSS Tables
HTML5 Web Page
CSS3 Designer
CSS3 Developer
Node.js Online Test
Javascript engine
packages
asynchronous programming
bug fixing
hands-on coding
Node.JS Developer
Node JS Engineer
React JS Online Test
Mounting Method
Render Function
Password Principles
Component Optimize
Default Values for Properties
Handling Events
React Facts
React.js Developer
JavaScript Developer – React.js
Front End Developer – React.js
React.js consultant
Web Developer
React Native Online Test
Components and Props
Javascript XML JSX
Static Image Resources
Network Images
Styling
Interactivity
React Native AppRegistry
Virtual DOM
FlexBox
ES5
ES6
TypeScript
React Native Developer
React Native Mobile Developer
Angular 2,4,6 Online Test
Data Binding
Controllers
Services
Templates
Expressions
Interpolation
Directives
Modules
AngularJS Programmer
AngularJS Front – End Developer
Senior Front End Developer Online Test
HTML5
AngularJS Application
JQuery - Application
CSS
Bootstrap - Application
Front End Developer (0-3 Years experience)
Web Developer
HTML and CSS Developer
UI Developer
Vue.js Test
Directives
Lifecycle
Router
Mixins
Components
Props
VueX
Templates
Conditional Rendering
Event Handling
Event Modifiers
Vue Forms
Vue Animation
Computed Properties
Binding
Handling state
Vue JS Developer
Vue JS Designer
JavaScript Developer
Web Front-End Developer
Senior Full-Stack Developer
Vue Engineer
Wordpress Test
Markdown Format
WordPress Features
WordPress Functions
Taxonomies in WordPress
Custom Widget
WordPress Developer
WordPress Designer
Core Java Test
Core Java
Data Types
Threads
Servlets
General Aptitude
Core Java Developer
Core Java Programmer
JQuery Test
JQuery Designer
JQuery Developer
Bootstrap Test (Advance)
Bootstrap Grid Classes
Bootstrap Collapse
CSS classes
Layouts in Bootstrap
Bootstrap JS
media queries in Bootstrap
UI Designer - Bootstrap
Sr. Web Developer - Bootstrap
ASP .NET Framework Test
ASP .Net AJAX Applications
ASP .Net Framework version 3.5
Classes
Methods
Categories
Web forms
Session Objects
Code Fragments
ASP .Net Developer - (0-3 years experience)
.Net Software Engineer
C# .NET OOPs Test
Class
Method
Object
Encapsulation
Inheritance
Constructors
Dot NET Application Developers
C# Software Developers
ASP.Net Web API Test
Message Handlers
Web API Controller
Query Validation Methods
Custom Handlers
Cookies and Client Request
.Net Web API Developer (0-3 yrs of experience)
ASP .Net Web API Developer
C# 6.0 test
Null-Conditional Operator
Static Using Syntax
Expression Bodied Function & Property
Boolean Comparison Operator
Increment Operators
Regular Expression
Disposal and Garbage Collection
C# Developer
C# Programmer

Check out sample Adaface MCQ questions on .NET Core topics

These are just a small sample from our premium questions library (10273 non-googleable questions).

Are you a candidate? Complete list of .NET Core interview questions 👇

Index

General

  1. What are some characteristics of .NET Core?
  2. What is CTS?
  3. What is Zero Garbage Collectors?
  4. Explain a simple GC implementation?
  5. When does Garbage collection occur?
  6. What is CoreFx?
  7. What is unit testing?
  8. What are Empty migrations?
  9. Differences Between .net Core and .net Framework?
  10. What are complex and supporting methods?
  11. What is FCL?
  12. What is IGCToCLR interface?
  13. What is Modularity?
  14. Defines the types and methods of a class library?
  15. What are the Fundamental Libraries?
  16. What are Generate SQL scripts in .Net core?
  17. Explain the difference between Task and Thread in .NET
  18. When should we use .NET Core and .NET Standard Class Library project types?
  19. What are the advantages that you could speak about Web API?
  20. What is meant by Web API routing?
  21. Briefly explain exception filters.
  22. Explain the difference between a class and an object.
  23. Explain LINQ.
  24. Explain the difference between the Stack and the Heap.
  25. What is a delegate in .NET?
  26. Define encapsulation.
  27. Is there a difference between ‘debug’ and ‘trace’?
  28. What’s inheritance?
  29. Define caching.
  30. What is a ‘.dll’ file?
  31. Can you specify access modifiers in an interface?
  32. What are advantages of Garbage Collection?
  33. What is UWP App in .Net core?
  34. What is MSBuild and how it works with .NET Core?
  35. How does MEF work?


The Questions
General
1. What are some characteristics of .NET Core?
  • Flexible deployment: Can be included in your app or installed side-by-side user- or machine-wide.
  • Cross-platform: Runs on Windows, macOS and Linux; can be ported to other OSes. The supported Operating Systems (OS), CPUs and application scenarios will grow over time, provided by Microsoft, other companies, and individuals.
  • Command-line tools: All product scenarios can be exercised at the command-line.
  • Compatible: .NET Core is compatible with .NET Framework, Xamarin and Mono, via the .NET Standard Library.
  • Open source: The .NET Core platform is open source, using MIT and Apache 2 licenses. Documentation is licensed under CC-BY. .NET Core is a .NET Foundation project.
  • Supported by Microsoft: .NET Core is supported by Microsoft, per .NET Core Support
2. What is CTS?

The Common Type System (CTS) standardizes the data types of all programming languages using .NET under the umbrella of .NET to a common data type for easy and smooth communication among these .NET languages. CTS is designed as a singly rooted object hierarchy with System.Object as the base type from which all other types are derived. CTS supports two different kinds of types: - Value Types: Contain the values that need to be stored directly on the stack or allocated inline in a structure. They can be built-in (standard primitive types), user-defined (defined in source code) or enumerations (sets of enumerated values that are represented by labels but stored as a numeric type). - Reference Types: Store a reference to the value‘s memory address and are allocated on the heap. Reference types can be any of the pointer types, interface types or self-describing types (arrays and class types such as user-defined classes, boxed value types and delegates).

3. What is Zero Garbage Collectors?

Zero Garbage Collectors is the simplest possible implementation that in fact does almost nothing. It only allows you to allocate objects because this is obviously required by the Execution Engine. Created objects are never automatically deleted and theoretically, no longer needed memory is never reclaimed.

4. Explain a simple GC implementation?

It is an excellent basis for the development of your own Garbage Collection mechanism. It provides the necessary functionality to make runtime work properly and you can build on top of that.

It may be interesting for special use cases like very short living applications or such that almost no allocate memory (you can come up with those concepts as No-alloc or Zero-alloc programming). In such a case providing GC overhead is unnecessary and it may be wise to get rid of it. It is like making huge GC.TryStartNoGCRegion overall your application.

5. When does Garbage collection occur?

Garbage collection occurs when one of the following conditions is true.

  • The system has low physical memory.
  • The memory that is used by allocated objects on the managed heap surpasses an acceptable threshold. This threshold is continuously adjusted as the process runs.
  • The GC.Collect method is called and in almost all cases, you do not have to call this method, because the garbage collector runs continuously. This method is primarily used for unique situations and testing.
6. What is CoreFx?

CoreFx is the reimplementation of the class libraries for .NET Core.

7. What is unit testing?

Unit testing is a development process for the software that has the smallest testable parts of an application, which are called units. They are individually and independently scrutinized for any proper operation. Unit testing is can either be automated or done manually as well.

8. What are Empty migrations?

Sometimes it's useful to add a migration without making any model changes. In this case, adding a new migration creates code files with empty classes. You can customize this migration to perform operations that don't directly relate to the EF Core model. Some things you might want to manage this way are: - Full-Text Search - Functions - Stored procedures - Triggers - Views

9. Differences Between .net Core and .net Framework?

The differences between the two can be summarized in these three points:

NuGet-based: .NET Core is distributed as a set of NuGet packages that allow app-local deployments. In contrast, the .NET-Framework is always installed in a system-wide location. This difference doesn’t matter so much for class libraries, but it matters for applications as those are expected to deploy the closure of their dependencies. But we expect this model to change how quickly class library authors can take advantage of new functionality. Since the applications can simply deploy a new version (as opposed to having to wait until a given .NET Framework version is widely adopted), there is less of a penalty for component authors to take advantage of the latest features.

Well layered: .NET Core was specifically designed to be layered. The goal was to create a .NET stack that can accommodate a wide variety of capabilities and system constraints without forcing customers to recompile their binaries and/or produce new assets. This means that we had to remove certain APIs because they tied lower-level components to higher-level components. In those cases, we provide alternatives, often in the form of extension methods.

Free of problematic tech: .NET Core doesn’t include certain technologies we decided to discontinue because we found them to be problematic, for instance, AppDomain and sandboxing. If the scenario still makes sense for .NET Core, our plan is to have replacements. For example, AssemblyLoadContext replaces AppDomains for loading and isolating assemblies.

10. What are complex and supporting methods?
  • The System.Numerics.Complex type represents a complex number, i.e., a number with a real number part and an imaginary number part
  • It supports a standard set of arithmetic, comparison, equality, explicit conversion, and implicit conversion operators, as well as mathematical, algebraic, and trigonometric methods.
11. What is FCL?

Framework Class Libraries (FCL)- The Framework class library (FCL) is a comprehensive collection of reusable types including classes, interfaces and data types included in the .NET-Framework to provide access to system functionality.

12. What is IGCToCLR interface?

This interface passed as an argument to the function InitializeGarbageCollector is used to communicate with the runtime. It contains quite a lot of available methods and listing them all here is pointless.

13. What is Modularity?

Modularity leads to performance benefits and your application can run faster, especially ASP.NET Core application.

14. Defines the types and methods of a class library?
  • A class the library defines the types and methods that can be called from any application.
  • A class the library developed using .NET Core supports the .NET Standard Library, which allows your library to be called by any .NET platform that supports that a version of the .NET Standard Library.
  • When you finish your class library, you can decide whether you want to distribute it as a third-party component, or whether you want to include it as a component that is bundled with one or more applications.
15. What are the Fundamental Libraries?

Fundamental Libraries − A set of framework libraries, which provide primitive data types, app composition types and fundamental utilities.

16. What are Generate SQL scripts in .Net core?

When debugging your migrations or deploying them to a production database, it's useful to generate a SQL script. The script can then be further reviewed for accuracy and tuned to fit the needs of a production database. The script can also be used in conjunction with a deployment technology.

17. Explain the difference between Task and Thread in .NET

Thread represents an actual OS-level thread, with its own stack and kernel resources. Thread allows the highest degree of control; you can Abort() or Suspend() or Resume() a thread, you can observe its state, and you can set thread-level properties like the stack size, apartment state, or culture. ThreadPool is a wrapper around a pool of threads maintained by the CLR.

The Task class from the Task Parallel Library offers the best of both worlds. Like the ThreadPool, a task does not create its own OS thread. Instead, tasks are executed by a TaskScheduler; the default scheduler simply runs on the ThreadPool. Unlike the ThreadPool, Task also allows you to find out when it finishes, and (via the generic Task) to return a result.

18. When should we use .NET Core and .NET Standard Class Library project types?

Use a .NET Standard library when you want to increase the number of apps that will be compatible with your library, and you are okay with a decrease in the .NET API surface area your library can access.

Use a .NET Core library when you want to increase the .NET API surface area your library can access, and you are okay with allowing only .NET Core apps to be compatible with your library.

19. What are the advantages that you could speak about Web API?

Content Negotiation, routing, and model bindings are some of the top picks that one could say when it comes to the advantages of Web API.

20. What is meant by Web API routing?

It is a pattern matching routine that is similar to what is found in MVC architecture. Route Tables contain all the routes that have been registered.

21. Briefly explain exception filters.

Exceptions that are thrown but are not handled will lead to the execution of exception filters. IExceptionFilter interface is implemented by the exception filters.

22. Explain the difference between a class and an object.

In short, a class is the definition of an object, and an object is instance of a class.

We can look at the class as a template of the object: it describes all the properties, methods, states and behaviors that the implementing object will have. As mentioned, an object is an instance of a class, and a class does not become an object until it is instantiated. There can be more instances of objects based on the one class, each with different properties.

23. Explain LINQ.

LINQ is an acronym for Language Integrated Query, and was introduced with Visual Studio 2008. LINQ is a set of features that extends query capabilities to the .NET language syntax by adding sets of new standard query operators that allow data manipulation, regardless of the data source. Supported data sources are: .NET Framework collections, SQL Server databases, ADO.NET Datasets, XML documents, and any collection of objects that support IEnumerable or the generic IEnumerable interface, in both C# and Visual Basic. In short, LINQ bridges the gap between the world of objects and the world of data

24. Explain the difference between the Stack and the Heap.

The short answer would be: in the Stack are stored value types (types inherited from System.ValueType), and in the Heap are stored reference types (types inherited from System.Object).

We can say the Stack is responsible for keeping track of what is actually executing and where each executing thread is (each thread has its own Stack). The Heap, on the other hand, is responsible for keeping track of the data, or more precise objects.

25. What is a delegate in .NET?

A delegate in .NET is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked. In addition, we could use delegate to create custom event within a class.

26. Define encapsulation.

Encapsulation is a function that includes various methods and data within a project. This is done so that the object of the program could perform its functions smoothly and without any errors.

27. Is there a difference between ‘debug’ and ‘trace’?

Yes. The Trace class can be used for debugging and releasing certain builds, while Debug is used solemnly for – you’ve guessed it – debugging.

This can be classified as one of the trick .NET interview questions, for it is quite easy to get forget about Trace’s additional function.

28. What’s inheritance?

Although this isn’t necessarily one of the primary .NET interview questions, it is still often asked because of how it relates to .NET.

Inheritance happens when one smaller class takes on the features and parameters of another, bigger class. This bigger class is then seen as a “parent class” to the smaller one.

This is also one of the better .NET framework interview questions to expand upon. .NET supports only single inheritance. What this means is that the smaller, child class can only benefit (inherit) from one parent class.

29. Define caching.

Caching is a process when you keep your most often used files and data in a separate memory. This separate location – a cache – is where you can access all of your designated files. Caching saves developers a lot of time and increases their memory management.

30. What is a ‘.dll’ file?

DLL files are those which need to be hidden out of plain sight. The term directly abbreviates to “Dynamic Link Library”. These libraries are vast, containing a huge amount of files and commands. DLLs can also be shared among other programs and apps. A small piece in .NET interview questions but can make a huge difference.

31. Can you specify access modifiers in an interface?

Assuming that the question relates to the item access modifiers – no, no you can’t. Why? Simply because the interface is always public.

32. What are advantages of Garbage Collection?

Garbage Collection provides the following benefits: - You don’t need to free the memory manually while developing your application. - It also allocates objects on the managed heap efficiently. - When objects are no longer used then it will reclaim those objects by clearing their memory, and keeps the memory available for future allocations. - Managed objects automatically get clean content to start with, so their constructors do not have to initialize every data field. - It also provides memory safety by making sure that an object cannot use the content of another object.

33. What is UWP App in .Net core?

UWP apps will be able to use libraries you have created in .net core as long as you target the .netstandard1.6 (or higher) framework moniker. UWP is only for the Windows ecosystem.

34. What is MSBuild and how it works with .NET Core?

MSBuild is the build platform for Microsoft and Visual Studio. In the UWP application if you open the project folder, then you will see both project.json and *.csproj files. But if you open our previous .NET Core Console app, then you will see project.json and *.xproj files.

35. How does MEF work?

It allows application developers to discover and use extensions with no configuration required. MEF is an integral part of the .NET Framework 4 and is available wherever the .NET-Framework is used that improves the flexibility, maintainability, and testability of large applications.