How can you achieve multiple inheritance in C#/.NET?

Achieving Multiple Inheritance in C#C# does not support multiple inheritance of classes to avoid complexity and the "Diamond Problem". However, multiple inheritance of type and behavior can be achieved using the following patterns:Multiple Interface Implementation: A class can implement any number of interfaces.Default Interface Methods (C# 8.0+): Interfaces can now provide default implementations, enabling multiple inheritance of behavior.Composition (Has-A Relationship): Delegating execution to helper classes rather than inheriting behavior.Code Example: Default Interface Methods vs. Composition// 1. Behavior Inheritance using C# 8.0 Default Interface Methods public interface IPrinter { void Print() => Console.WriteLine("Printing..."); } public interface IScanner { void Scan() => Console.WriteLine("Scanning..."); } public class MultiFunctionDevice : IPrinter, IScanner { // Synthesized class inherits both default implementations } // 2. State & Behavior Reuse using Composition public class Engine { public void Start() => Console.WriteLine("Engine started."); } public class Autopilot { public void Navigate() => Console.WriteLine("Navigating..."); } public class AutonomousCar { private readonly Engine _engine = new(); private readonly Autopilot _autopilot = new(); public void Drive() { _engine.Start(); _autopilot.Navigate(); } }

How would you use Dependency Injection to choose between SMS and Email notifications?

Architectural Approaches to Dynamic Service SelectionIn .NET Core, dynamically choosing between implementations (like SMS and Email) can be achieved using three main patterns depending on your target .NET version and architectural preferences:1. The Strategy Pattern with IEnumerable<T> (Classic Approach)Register all implementations of your interface in the DI container. Then, inject the collection and filter the desired instance at runtime based on metadata.public enum NotificationType { Email, Sms } public interface INotificationService { NotificationType Type { get; } Task SendAsync(string recipient, string message); } public class EmailNotificationService : INotificationService { public NotificationType Type => NotificationType.Email; public async Task SendAsync(string recipient, string message) => Console.WriteLine($"Email sent to {recipient}"); } public class SmsNotificationService : INotificationService { public NotificationType Type => NotificationType.Sms; public async Task SendAsync(string recipient, string message) => Console.WriteLine($"SMS sent to {recipient}"); } // DI Registration builder.Services.AddTransient<INotificationService, EmailNotificationService>(); builder.Services.AddTransient<INotificationService, SmsNotificationService>(); // Usage inside a Controller or Service public class NotificationDispatcher { private readonly IEnumerable<INotificationService> _services; public NotificationDispatcher(IEnumerable<INotificationService> services) { _services = services; } public async Task DispatchAsync(NotificationType type, string recipient, string message) { var service = _services.FirstOrDefault(s => s.Type == type) ?? throw new NotSupportedException($"No service registered for {type}"); await service.SendAsync(recipient, message); } }2. Keyed Services (.NET 8+ Recommended Approach)Starting with .NET 8, Keyed Services are supported out-of-the-box, allowing you to associate a key (like an enum or string) with registrations.// DI Registration builder.Services.AddKeyedTransient<INotificationService, EmailNotificationService>("Email"); builder.Services.AddKeyedTransient<INotificationService, SmsNotificationService>("SMS"); // Usage via Injection public class NotificationController : ControllerBase { private readonly IServiceProvider _serviceProvider; public NotificationController(IServiceProvider serviceProvider) { _serviceProvider = serviceProvider; } [HttpPost] public async Task<IActionResult> Send(string channel, string recipient, string message) { var service = _serviceProvider.GetKeyedService<INotificationService>(channel); if (service == null) return BadRequest("Invalid Channel"); await service.SendAsync(recipient, message); return Ok(); } }3. Factory Delegate RegistrationIf you are using pre-.NET 8 versions but do not want to inject all implementations everywhere, you can register a factory delegate in DI.// Register the Factory delegate in DI builder.Services.AddTransient<EmailNotificationService>(); builder.Services.AddTransient<SmsNotificationService>(); builder.Services.AddTransient<Func<NotificationType, INotificationService>>(serviceProvider => type => type switch { NotificationType.Email => serviceProvider.GetRequiredService<EmailNotificationService>(), NotificationType.Sms => serviceProvider.GetRequiredService<SmsNotificationService>(), _ => throw new NotSupportedException() }); // Usage public class CommunicationManager { private readonly Func<NotificationType, INotificationService> _factory; public CommunicationManager(Func<NotificationType, INotificationService> factory) { _factory = factory; } public async Task Execute(NotificationType type, string target, string body) { var notifier = _factory(type); await notifier.SendAsync(target, body); } }

What are database indexes?

A database index is a specialized, separate data structure (typically a B-Tree) that improves the speed of data retrieval operations on a database table at the cost of additional write overhead and storage space.Key Types of IndexesClustered Index: Determines the physical order of the data stored inside the table. Because physical data can only be sorted in one way, there can be only one clustered index per table (by default, the Primary Key).Non-Clustered Index: A structure completely separate from the data rows. It contains the indexed columns and a pointer (such as a row locator or the clustered index key) back to the physical row containing the rest of the data.Configuring Indexes in EF Core (.NET Core)In .NET Core applications using Entity Framework Core, indexes are usually managed via migrations using either Data Annotations or the Fluent API:// Configuring a composite, unique index via Fluent API in EF Core protected override void OnModelCreating(ModelBuilder modelBuilder) { modelBuilder.Entity<User>() .HasIndex(u => new { u.Email, u.TenantId }) .IsUnique(); }

What are MAUI Handlers and why did they replace Xamarin.Forms Renderers?

Explain the MAUI Handler architecture, its relationship with native controls, and the advantages over the older Xamarin.Forms Renderer approach.

What are the different types of Design Patterns?

Describe common software design patterns such as Creational, Structural, and Behavioral patterns, with examples relevant to .NET development.

What are the different types of indexes?

Explain common SQL Server index types such as clustered, non-clustered, unique, composite, filtered, and covering indexes.

What are the SOLID principles?

The SOLID PrinciplesSOLID is an acronym representing five core design principles of object-oriented programming and design. When applied to .NET Core development, they promote maintainability, scalability, and testability, facilitating seamless integration with .NET Core's built-in dependency injection container.S - Single Responsibility Principle (SRP): A class should have one, and only one, reason to change. Meaning, a class should have only one job or responsibility.O - Open/Closed Principle (OCP): Software entities (classes, modules, functions) should be open for extension but closed for modification. You should be able to add new functionality without changing existing code.L - Liskov Substitution Principle (LSP): Subtypes must be substitutable for their base types. An object of a superclass should be replaceable with an object of a subclass without breaking the application.I - Interface Segregation Principle (ISP): Clients should not be forced to depend on methods they do not use. It is better to have many small, specific interfaces rather than one large, general-purpose interface.D - Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions (interfaces). Abstractions should not depend on details; details should depend on abstractions.C# Example: Violating and Adhering to DIPViolating DIP (Tight Coupling):public class Car { // Tight coupling to a concrete low-level class private Engine _engine = new Engine(); public void Start() { _engine.Ignite(); } }Adhering to DIP (Using ASP.NET Core DI):public interface IEngine { void Ignite(); } public class Engine : IEngine { public void Ignite() { /* Integration logic */ } } public class Car { private readonly IEngine _engine; // Constructor injection via ASP.NET Core Built-in DI container public Car(IEngine engine) { _engine = engine; } public void Start() { _engine.Ignite(); } }

What is a Common Table Expression (CTE)?

What is a Common Table Expression (CTE)?A Common Table Expression (CTE) is a temporary named result set that you can reference within a single SELECT, INSERT, UPDATE, or DELETE statement. Defined using the WITH clause, a CTE exists only during the execution of that specific query and helps simplify complex nested subqueries.Basic CTE SyntaxWITH Sales_CTE (RepID, TotalSales) AS ( SELECT SalesRepID, SUM(Amount) FROM Orders GROUP BY SalesRepID ) SELECT RepID, TotalSales FROM Sales_CTE WHERE TotalSales > 10000;CTEs are categorized into two main types:Non-Recursive CTEs: Standard CTEs used to break down complex queries into readable, modular parts.Recursive CTEs: CTEs that reference themselves, making them highly powerful for querying hierarchical data structures like organizational charts, folder paths, or bill of materials.

What is a DataTemplateSelector in .NET MAUI?

What is a DataTemplateSelector?In .NET MAUI, a DataTemplateSelector is a class that allows developers to dynamically choose a DataTemplate at runtime based on the properties of a data-bound object in a collection (such as a CollectionView or ListView).This is particularly useful when displaying a list of heterogeneous data, where different types of items require entirely different visual layouts. For example, a chat application displaying both incoming and outgoing messages, or a social media feed containing text, images, and video posts.How to Implement ItTo implement a custom template selector, you must:Inherit from the DataTemplateSelector class.Expose properties of type DataTemplate for each layout.Override the OnSelectTemplate method to write the selection logic.Here is a code example of a custom template selector:using Microsoft.Maui.Controls; namespace MyApp.Selectors { public class MessageTemplateSelector : DataTemplateSelector { public DataTemplate IncomingTemplate { get; set; } public DataTemplate OutgoingTemplate { get; set; } protected override DataTemplate OnSelectTemplate(object item, BindableObject container) { var message = item as MessageDto; if (message == null) return null; return message.IsIncoming ? IncomingTemplate : OutgoingTemplate; } } }Consuming It in XAMLDefine the templates and the selector in your page's Resource Dictionary, and then assign the selector to your CollectionView's ItemTemplate:<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:selectors="clr-namespace:MyApp.Selectors" x:Class="MyApp.MainPage"> <ContentPage.Resources> <DataTemplate x:Key="IncomingLayout"> <HorizontalStackLayout Padding="10" BackgroundColor="LightGray"> <Label Text="{Binding Text}" TextColor="Black" /> </HorizontalStackLayout> </DataTemplate> <DataTemplate x:Key="OutgoingLayout"> <HorizontalStackLayout Padding="10" HorizontalOptions="End" BackgroundColor="LightBlue"> <Label Text="{Binding Text}" TextColor="Black" /> </HorizontalStackLayout> </DataTemplate> <selectors:MessageTemplateSelector x:Key="MyMessageSelector" IncomingTemplate="{StaticResource IncomingLayout}" OutgoingTemplate="{StaticResource OutgoingLayout}" /> </ContentPage.Resources> <CollectionView ItemTemplate="{StaticResource MyMessageSelector}" ItemsSource="{Binding Messages}" /> </ContentPage>

What is MVVM in .NET MAUI?

Understanding MVVM in .NET MAUIMVVM (Model-View-ViewModel) is an architectural pattern widely used in .NET MAUI (Multi-platform App UI) to decouple user interface (UI) presentation logic from business logic and data. It leverages .NET MAUI's powerful Data Binding engine to sync data between the View and the ViewModel automatically.Here is a summary of the core components:Model: Represents the domain data, entities, and business rules (e.g., a Product class).View: The user interface layer, typically defined in XAML (e.g., ProductPage.xaml). It handles rendering and layout.ViewModel: Acts as a state machine and intermediary. It exposes properties and commands that the View binds to, and updates the Model. It implements the INotifyPropertyChanged interface to notify the View of state changes.Modern MVVM with CommunityToolkit.MvvmIn modern .NET MAUI development, boilerplate code is minimized using Source Generators provided by the CommunityToolkit.Mvvm NuGet package. Below is a practical implementation:The ViewModel (C#)using CommunityToolkit.Mvvm.ComponentModel; using CommunityToolkit.Mvvm.Input; namespace MyMauiApp.ViewModels; public partial class MainViewModel : ObservableObject { [ObservableProperty] private string _userName; [RelayCommand] private async Task SubmitAsync() { if (!string.IsNullOrWhiteSpace(UserName)) { await App.Current.MainPage.DisplayAlert("Success", $"Hello, {UserName}!", "OK"); } } }The View (XAML)<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui" xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" xmlns:viewmodel="clr-namespace:MyMauiApp.ViewModels" x:Class="MyMauiApp.Views.MainPage" x:DataType="viewmodel:MainViewModel"> <VerticalStackLayout Padding="30" Spacing="15"> <Entry Text="{Binding UserName, Mode=TwoWay}" Placeholder="Enter your name" /> <Button Text="Submit" Command="{Binding SubmitCommand}" /> </VerticalStackLayout> </ContentPage>

What is the difference between a Singleton and a static class?

The Core DifferenceWhile both Singleton and Static Classes are used to ensure a single instance or entry point, they serve fundamentally different purposes in object-oriented programming (OOP) and .NET Core architecture.Object-Oriented Design: A Singleton is a true object that implements a design pattern. It can implement interfaces, inherit from base classes, and support polymorphism. A static class is a language-level construct that cannot be instantiated, cannot inherit, and cannot implement interfaces.Dependency Injection & Testability: In .NET Core, Singletons are highly compatible with Dependency Injection (DI) and can be easily mocked for unit testing. Static classes introduce tight coupling and are notoriously difficult to mock.Lifecycle Management: A Singleton's lifetime can be managed by a DI container (e.g., IServiceCollection.AddSingleton), enabling lazy initialization or scoped disposals. Static classes are loaded by the CLR when referenced and persist for the lifetime of the AppDomain, making clean teardown difficult.

What is the difference between a Thread and a Task in C#?

In C#, a Thread represents an actual OS-level execution thread with its own stack and kernel resources, whereas a Task is an abstraction from the Task Parallel Library (TPL) representing an asynchronous operation that may or may not run on a separate thread.Key Differences:Abstraction Level: Thread is a low-level, OS-facing API. Task is a high-level abstraction built on top of the ThreadPool.Resource Consumption: Creating a Thread is highly expensive (allocating ~1MB of stack memory by default). Tasks are extremely lightweight and reuse existing threads from the global pool, reducing context-switching overhead.Return Values: Thread does not natively return a value (requiring shared state or custom callback mechanics). A Task<TResult> natively supports returning a result.Composition and Chaining: Tasks support fluent composition, continuation (using ContinueWith or async/await), and parent/child hierarchies. Threads cannot easily be chained or coordinated.Cancellation: Tasks integrate seamlessly with cooperative cancellation via CancellationToken, whereas interrupting or aborting a raw Thread is dangerous and deprecated in .NET Core.

What is the difference between software architecture and a design pattern?

Software Architecture vs. Design PatternsIn software engineering, especially within the .NET Core ecosystem, Software Architecture and Design Patterns operate at different levels of abstraction, scope, and detail.1. Software Architecture (The "Big Picture")Software Architecture defines the high-level structure of a system, its components, and how they interact with each other. It focuses on non-functional requirements (system attributes) such as scalability, maintainability, security, deployment, and performance.Scope: System-wide or enterprise-wide.Impact of Change: Extremely high. Changing architectural decisions late in the project is difficult and expensive.Examples in .NET Core: Clean/Onion Architecture: Separating business logic from external concerns (UI, Database).Microservices Architecture: Splitting a .NET Core application into independently deployable services using API Gateways, gRPC, or RabbitMQ.Event-Driven Architecture: Using message brokers like Azure Service Bus or Kafka.2. Design Patterns (The "Local Solution")Design Patterns are reusable, localized solutions to commonly occurring software design problems within a specific context. They deal with the structural organization of code, object creation, and behavioral interaction between classes.Scope: Localized (typically limited to a subsystem, module, or a set of closely related classes).Impact of Change: Medium to Low. Patterns can be refactored or replaced with relatively local code modifications.Examples in .NET Core: Dependency Injection (DI): Built natively into ASP.NET Core via IServiceCollection.Repository & Unit of Work: Decoupling the data access layer (often using Entity Framework Core) from business logic.Mediator Pattern: Used via libraries like MediatR to decouple request senders from handlers in CQRS.

What is the Liskov Substitution Principle?

The Liskov Substitution Principle (LSP) is a fundamental rule in object-oriented design and is the "L" in the SOLID principles. It states that: Objects of a superclass should be replaceable with objects of its subclasses without breaking the application or altering its correctness.In C# and .NET development, a subclass should not only inherit the syntax (methods and properties) of its parent, but must also respect the behavioral contract expected by the client calling the base class.Example of an LSP Violationpublic class FileStream { public virtual void Write(byte[] data) { /* Write logic */ } } public class ReadOnlyFileStream : FileStream { public override void Write(byte[] data) { // Violates LSP by throwing an unexpected exception throw new NotSupportedException("Cannot write to a read-only stream."); } }Any client code expecting to safely call Write() on a FileStream will crash if it receives an instance of ReadOnlyFileStream.The Solution (Adhering to LSP)To adhere to LSP, we should refactor our abstractions using interfaces or segregated hierarchies so that subclasses do not inherit behaviors they cannot fulfill:public interface IReadable { void Read(); } public interface IWritable { void Write(byte[] data); } public class ReadOnlyStream : IReadable { public void Read() { /* Read implementation */ } } public class ReadWriteStream : IReadable, IWritable { public void Read() { /* Read implementation */ } public void Write(byte[] data) { /* Write implementation */ } }

What is the Open/Closed Principle?

The Open/Closed Principle (OCP) is one of the five SOLID design principles of object-oriented programming. It states that software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.This means you should be able to add new functionality or behaviors to a system without altering existing, tested code. In .NET Core, this is typically achieved using interfaces, abstract classes, polymorphism, and Dependency Injection (DI).Violating OCP (Bad Practice)Using conditional blocks (like if-else or switch) based on types or enums forces you to modify the existing class every time a new business rule is added:public class TaxCalculator { public double CalculateTax(double amount, string country) { if (country == "USA") return amount * 0.08; if (country == "UK") return amount * 0.20; // Every new country requires modifying this tested class throw new ArgumentException("Unsupported country"); } }Adhering to OCP (Good Practice)By defining an abstraction (interface) and using polymorphism, you can add new countries simply by creating new classes without touching the existing logic:public interface ITaxStrategy { string Country { get; } double Calculate(double amount); } public class UsTaxStrategy : ITaxStrategy { public string Country => "USA"; public double Calculate(double amount) => amount * 0.08; } public class TaxCalculator { private readonly IEnumerable<ITaxStrategy> _strategies; public TaxCalculator(IEnumerable<ITaxStrategy> strategies) { _strategies = strategies; } public double CalculateTax(double amount, string country) { var strategy = _strategies.FirstOrDefault(s => s.Country == country); return strategy != null ? strategy.Calculate(amount) : throw new ArgumentException("Unsupported country"); } }

Which SOLID principles are violated in this EmployeeViewModel design?

Violations in a Common "Fat" EmployeeViewModel DesignIn many legacy or poorly architected .NET applications, a ViewModel often grows into a "God Object" that violates multiple SOLID principles. Consider the following problematic implementation:public class EmployeeViewModel : ViewModelBase { // 1. Violation of DIP: Direct coupling to concrete instances private readonly SqlEmployeeRepository _repository = new SqlEmployeeRepository(); private readonly SmtpEmailService _emailService = new SmtpEmailService(); public string Name { get; set; } public string Email { get; set; } public EmployeeType Role { get; set; } public decimal Salary { get; set; } public async Task SaveEmployeeAsync() { // 2. Violation of SRP: ViewModel handles validation and persistence if (string.IsNullOrEmpty(Name) || !Email.Contains("@")) throw new ValidationException("Invalid input data"); var emp = new Employee { Name = Name, Email = Email, Role = Role, Salary = Salary }; await _repository.AddAsync(emp); // 3. Violation of SRP: ViewModel coordinates side-effects like sending emails _emailService.SendWelcomeEmail(Email); } public decimal CalculateBonus() { // 4. Violation of OCP: Hardcoded business rules using switch-cases switch (Role) { case EmployeeType.Manager: return Salary * 0.2m; case EmployeeType.Developer: return Salary * 0.1m; default: return Salary * 0.05m; } } }In this design, the following three key SOLID principles are violated:Single Responsibility Principle (SRP): The class has multiple reasons to change. It is responsible for holding UI state, performing input validation, orchestrating data persistence, executing business logic (bonus calculation), and dispatching emails.Open/Closed Principle (OCP): The CalculateBonus method uses a switch statement based on EmployeeType. If a new employee type is introduced (e.g., QAEngineer), this class must be modified, making it closed to extension and open to modification.Dependency Inversion Principle (DIP): The ViewModel directly instantiates SqlEmployeeRepository and SmtpEmailService (high-level modules depending directly on low-level modules). This prevents mockability, breaks testability, and tightly couples the UI layer to SQL Server and SMTP configurations.

Why might Blazor WebAssembly be preferred over React in some scenarios?

While React remains the dominant library for building modern client-side web applications, Blazor WebAssembly (Wasm) is highly preferred in specific scenarios, particularly in enterprise environments with existing .NET ecosystems. Blazor Wasm can be preferred over React due to the following key benefits:Single Language Stack (C# End-to-End): It allows developers to write both client-side UI and backend services in C#. This eliminates the cognitive load of context-switching between C# on the backend and JavaScript/TypeScript on the frontend.Direct Code Sharing: You can share actual C# classes, DTOs, and validation logic (such as FluentValidation or DataAnnotations) directly between the frontend client and the backend API, preventing duplicate code bases.Leveraging the .NET Ecosystem: Blazor Wasm runs on a WebAssembly-based .NET runtime, allowing developers to import existing NuGet packages and standard .NET libraries directly into the browser.Strong Compile-Time Safety: Unlike JavaScript (and even TypeScript's transpiled layer), C# provides rigorous static typing at compile time across the entire application stack, reducing runtime errors.Simplified Build Pipelines: It removes the need for complex JavaScript build tools (e.g., Webpack, Vite, npm/yarn) and security vulnerability concerns from deep npm dependency trees, unifying everything under the standard .NET CLI and MSBuild.

Why should you not create indexes on every column?

The Short AnswerCreating an index on every column is a major database design anti-pattern. While indexes significantly speed up data retrieval (SELECT queries), they come with a high cost that impacts database performance and resource utilization.You should not index every column for three primary reasons:Severe Write Performance Degradation: Every INSERT, UPDATE, and DELETE operation must not only modify the table data but also update and rebalance all affected indexes.Storage and Buffer Pool Bloat: Indexes consume substantial disk space and, more importantly, RAM. Excess indexes crowd out actual data pages from the database's memory buffer pool, slowing down the entire system.Query Optimizer Overheads: Having too many candidate indexes increases query compilation times because the query optimizer has to evaluate a massive number of execution paths. This can occasionally lead to the optimizer choosing suboptimal plans.

Why would you use a CTE instead of a temporary table or table variable?

A Common Table Expression (CTE) is used instead of a temporary table (#temp) or a table variable (@temp) primarily because of its declarative nature, readability, and performance characteristics in specific scenarios.Here is a direct breakdown of why and when you would choose a CTE:Readability and Maintainability: CTEs organize complex queries into logical, sequential blocks. They act as virtual views defined only for the scope of a single query, making the code much easier to read than deeply nested subqueries or multiple procedural temporary tables.Recursion: CTEs natively support hierarchical or recursive queries (using the UNION ALL syntax), which are incredibly difficult or highly inefficient to replicate using temporary tables or table variables.No TempDB Metadata Overhead: Unlike temporary tables, CTEs do not write metadata or schema definitions to the tempdb database. They are evaluated inline by the query optimizer.Inline Optimization: The SQL Server Query Optimizer can merge the CTE definition directly into the execution plan of the outer query, allowing it to utilize existing table indexes and statistics dynamically.Code Comparison ExampleUsing a CTE for a clean, single-statement execution:-- CTE Approach (Readable, single query scope) WITH OrderedOrders AS ( SELECT CustomerID, OrderDate, TotalAmount, ROW_NUMBER() OVER(PARTITION BY CustomerID ORDER BY OrderDate DESC) as rn FROM Orders ) SELECT CustomerID, OrderDate, TotalAmount FROM OrderedOrders WHERE rn = 1;Using a Temporary Table (Procedural, writes to tempdb):-- Temporary Table Approach CREATE TABLE #OrderedOrders ( CustomerID INT, OrderDate DATETIME, TotalAmount DECIMAL(18,2), rn INT ); INSERT INTO #OrderedOrders SELECT CustomerID, OrderDate, TotalAmount, ROW_NUMBER() OVER(PARTITION BY CustomerID ORDER BY OrderDate DESC) FROM Orders; SELECT CustomerID, OrderDate, TotalAmount FROM #OrderedOrders WHERE rn = 1; DROP TABLE #OrderedOrders;

.Net Core Interview Questions

Answer

The Short Answer

For 10 lakh (1 million) records, you should use CollectionView in .NET MAUI. However, the critical architectural caveat is that you must never load all 10 lakh records into memory at once, regardless of the control used.

You should combine CollectionView with Incremental Loading (Pagination / Infinite Scrolling) using the RemainingItemsThreshold and RemainingItemsThresholdReachedCommand properties. This ensures UI virtualization is coupled with data virtualization, preventing the application from crashing due to an OutOfMemoryException on mobile devices.

Recommended Implementation Pattern

<!-- XAML Implementation -->
<CollectionView ItemsSource="{Binding Items}"
                RemainingItemsThreshold="5"
                RemainingItemsThresholdReachedCommand="{Binding LoadMoreItemsCommand}">
    <CollectionView.ItemTemplate>
        <DataTemplate x:DataType="models:MyModel">
            <Grid Padding="10">
                <Label Text="{Binding Name}" />
            </Grid>
        </DataTemplate>
    </CollectionView.ItemTemplate>
</CollectionView>

Answered by:MOMohammed Musab Khan

Explanation

Why CollectionView is Superior for Large Datasets

While both ListView and CollectionView support UI virtualization (reusing visual elements/cells as the user scrolls), CollectionView is the modern, optimized control designed to replace ListView in .NET MAUI. Here is a comparison of their performance mechanics:

No ViewCell Wrapping: Unlike ListView, which requires wrapping templates in a ViewCell (adding extra layout cycles and rendering overhead), CollectionView directly renders the specified elements, reducing the visual tree depth.
Native UI Virtualization: CollectionView leverages the native platform's highly optimized recycling lists (e.g., RecyclerView on Android and UICollectionView on iOS) directly, resulting in smoother scrolling and less CPU overhead.
Built-In Incremental Loading: CollectionView natively supports loading data incrementally through RemainingItemsThreshold. ListView requires hacky scroll-listening workarounds to achieve clean pagination.

The 1 Million Records Bottleneck: Memory Management

At 1,000,000 records, the primary bottleneck is not UI rendering, but RAM utilization on the client device. Storing 1 million C# objects in an ObservableCollection<T> will instantly crash a mobile app due to memory constraints.

To solve this, implement Data Virtualization:

Paginated API Requests: Fetch data in small chunks (e.g., 20 to 50 items per request).
Append-on-Scroll: Use the RemainingItemsThresholdReachedCommand to trigger an asynchronous call to fetch the next page and append only those new items to the bound collection.
Keep Layouts Flat: Ensure the ItemTemplate is as flat as possible. Avoid deeply nested StackLayouts; use a single-row/column Grid instead to minimize measurement passes.

Tips & Hints

Interview Tips & Architecture Discussion Points

Acknowledge the Scale: Start your answer by highlighting that 10 lakh records is a massive dataset for a front-end client. This immediately demonstrates your senior-level understanding that UI controls alone cannot solve systemic data scaling issues.
Differentiate UI vs. Data Virtualization: Explain that CollectionView solves UI Virtualization (keeping only visible UI elements in memory), but the developer must solve Data Virtualization (keeping only a subset of the dataset in memory).
Highlight Pitfalls to Avoid: Mention that developers should avoid setting HasUnevenRows="True" if possible (or keep item heights consistent) because dynamic height calculations add substantial layout overhead when scrolling rapidly.
Pro Tip (Data Templating): Mention that using compiled bindings (x:DataType) inside the DataTemplate is critical for high-performance scrolling in MAUI as it avoids reflection at runtime.

Asked at:

Accenture

Capgemini

Cognizant

EPAM Systems

Microsoft

.Net Core Interview Questions

Questions and Answers

For 10 lakh records, would you use CollectionView or ListView in .NET MAUI?

Answer

The Short Answer

Recommended Implementation Pattern

Explanation

Why CollectionView is Superior for Large Datasets

The 1 Million Records Bottleneck: Memory Management

Tips & Hints

Interview Tips & Architecture Discussion Points

How can you achieve multiple inheritance in C#/.NET?

How would you use Dependency Injection to choose between SMS and Email notifications?

What are database indexes?

What are MAUI Handlers and why did they replace Xamarin.Forms Renderers?

What are the different types of Design Patterns?

What are the different types of indexes?

What are the SOLID principles?

What is a Common Table Expression (CTE)?

What is a DataTemplateSelector in .NET MAUI?

What is MVVM in .NET MAUI?

What is the difference between a Singleton and a static class?

What is the difference between a Thread and a Task in C#?

What is the difference between software architecture and a design pattern?

What is the Liskov Substitution Principle?

What is the Open/Closed Principle?

Which SOLID principles are violated in this EmployeeViewModel design?

Why might Blazor WebAssembly be preferred over React in some scenarios?

Why should you not create indexes on every column?

Why would you use a CTE instead of a temporary table or table variable?

Topic Overview

Relevant Job Opportunities

Topic Switcher

Adjacent Tracks

Master .Net Core Interview Questions Fast

Questions and Answers

Q1AdvancedAccentureCapgeminiFor 10 lakh records, would you use CollectionView or ListView in .NET MAUI?

For 10 lakh records, would you use CollectionView or ListView in .NET MAUI?

Answer

The Short Answer

Recommended Implementation Pattern

Explanation

Why CollectionView is Superior for Large Datasets

The 1 Million Records Bottleneck: Memory Management

Tips & Hints

Interview Tips & Architecture Discussion Points

Q2AdvancedAccentureAmazonHow can you achieve multiple inheritance in C#/.NET?

How can you achieve multiple inheritance in C#/.NET?

Q3AdvancedAccentureAmazonHow would you use Dependency Injection to choose between SMS and Email notifications?

How would you use Dependency Injection to choose between SMS and Email notifications?

Q4AdvancedAccentureDeutsche BankWhat are database indexes?

What are database indexes?

Q5IntermediateWhat are MAUI Handlers and why did they replace Xamarin.Forms Renderers?

What are MAUI Handlers and why did they replace Xamarin.Forms Renderers?

Q6IntermediateWhat are the different types of Design Patterns?

What are the different types of Design Patterns?

Q7IntermediateWhat are the different types of indexes?

What are the different types of indexes?

Q8AdvancedAccentureAmazonWhat are the SOLID principles?

What are the SOLID principles?

Q9IntermediateAccentureCapgeminiWhat is a Common Table Expression (CTE)?

What is a Common Table Expression (CTE)?

Q10IntermediateAccentureAvanadeWhat is a DataTemplateSelector in .NET MAUI?

What is a DataTemplateSelector in .NET MAUI?

Q11AdvancedAccentureAvanadeWhat is MVVM in .NET MAUI?

What is MVVM in .NET MAUI?

Q12AdvancedAccentureAmazonWhat is the difference between a Singleton and a static class?

What is the difference between a Singleton and a static class?

Q13AdvancedAmazonEPAM SystemsWhat is the difference between a Thread and a Task in C#?

What is the difference between a Thread and a Task in C#?

Q14IntermediateAccentureAmazonWhat is the difference between software architecture and a design pattern?

What is the difference between software architecture and a design pattern?

Q15AdvancedAmazonCapgeminiWhat is the Liskov Substitution Principle?

What is the Liskov Substitution Principle?

Q16AdvancedAccentureAmazonWhat is the Open/Closed Principle?

What is the Open/Closed Principle?

Q17AdvancedAccentureCapgeminiWhich SOLID principles are violated in this EmployeeViewModel design?

Which SOLID principles are violated in this EmployeeViewModel design?

Q18AdvancedHoneywellMicrosoftWhy might Blazor WebAssembly be preferred over React in some scenarios?

Why might Blazor WebAssembly be preferred over React in some scenarios?

Q19AdvancedAmazonEPAM SystemsWhy should you not create indexes on every column?

Why should you not create indexes on every column?

Q20AdvancedAccentureEPAM SystemsWhy would you use a CTE instead of a temporary table or table variable?

Why would you use a CTE instead of a temporary table or table variable?

Topic OverviewOpen the full background, concepts covered, and context for this topic.

Topic Overview

Relevant Job Opportunities

Topic Switcher

Adjacent Tracks

Master .Net Core Interview Questions Fast