1. What is the .NET Framework?
- The .NET Framework is a software development platform developed by Microsoft.
- It provides a consistent programming model and a comprehensive set of libraries to build various applications such as web, desktop, and mobile apps.
- It consists of two major components:
- Common Language Runtime (CLR): Handles memory management, exception handling, and garbage collection.
- .NET Framework Class Library (FCL): Provides reusable classes and APIs for development.
Example:
using System;
class Program
{
static void Main()
{
Console.WriteLine("Hello, .NET Framework!");
}
}
2. What is the Common Language Runtime (CLR)?
- CLR is the heart of the .NET Framework, responsible for executing .NET programs.
- It provides key services:
- Memory management (using garbage collection).
- Exception handling.
- Thread management.
- Security management.
Key Features of CLR:
- Just-In-Time (JIT) Compilation: Converts Intermediate Language (IL) code to machine code.
- Garbage Collection (GC): Automatically frees memory by removing objects that are no longer in use.
Example:
public class Example
{
public void ShowMessage()
{
Console.WriteLine("CLR manages this execution.");
}
}
3. What is the difference between .NET Framework and .NET Core?
- .NET Framework:
- Runs only on Windows.
- Used for building Windows-specific applications like desktop apps.
- Larger runtime and library support.
- .NET Core:
- Cross-platform (supports Windows, Linux, macOS).
- Lightweight and modular.
- Primarily used for web, cloud, and cross-platform apps.
4. What are Assemblies in .NET?
- Assemblies are the building blocks of a .NET application.
- An assembly is a compiled code that CLR can execute. It can be either an EXE (for applications) or a DLL (for reusable components).
Types of Assemblies:
- Private Assembly: Used by a single application.
- Shared Assembly: Can be shared across multiple applications (e.g., libraries stored in GAC).
Example:
// Compiling this code will create an assembly (DLL or EXE)
public class SampleAssembly
{
public void DisplayMessage()
{
Console.WriteLine("This is an assembly example.");
}
}
5. What is the Global Assembly Cache (GAC)?
- GAC is a machine-wide code cache that stores assemblies specifically designated to be shared by several applications on the computer.
- Assemblies in GAC are strongly named and allow multiple versions of the same assembly to be maintained side by side.
Example:
// To add an assembly to the GAC (in command prompt)
gacutil -i MyAssembly.dll
6. What are Namespaces in .NET?
- Namespaces are used to organize classes and other types in .NET.
- They prevent naming conflicts by logically grouping related classes.
Example:
namespace MyNamespace
{
public class MyClass
{
public void Greet()
{
Console.WriteLine("Hello from MyNamespace!");
}
}
}
7. What is Managed Code?
- Managed Code is the code that runs under the control of the CLR.
- CLR manages execution, garbage collection, and other system services for the code.
Example:
// This is managed code because it's executed by CLR
public class ManagedCodeExample
{
public void Print()
{
Console.WriteLine("Managed Code Example.");
}
}
8. What is Unmanaged Code?
- Unmanaged Code is code executed directly by the operating system, not under the control of CLR.
- Examples include applications written in C or C++ that are compiled directly into machine code.
Example:
// Calling unmanaged code from C#
[DllImport("User32.dll")]
public static extern int MessageBox(IntPtr hWnd, String text, String caption, int options);
9. What is the difference between Value Types and Reference Types in .NET?
- Value Types:
- Stored directly in memory.
- Examples:
int, float, bool.
- Reference Types:
- Store a reference (pointer) to the actual data in memory.
- Examples:
class, object, string.
Example:
// Value type
int x = 10;
// Reference type
string name = "John";
10. What is Boxing and Unboxing in .NET?
- Boxing: Converting a value type to an object (reference type).
- Unboxing: Extracting the value type from an object.
Example:
// Boxing
int num = 123;
object obj = num; // Boxing
// Unboxing
int unboxedNum = (int)obj; // Unboxing
11. What is the Common Type System (CTS)?
- CTS defines all data types in the .NET Framework and how they are represented in memory.
- It ensures that data types used across different .NET languages (C#, VB.NET, F#) are compatible with each other.
- Value Types (stored in the stack) and Reference Types (stored in the heap) are both part of CTS.
Example:
12. What is the Common Language Specification (CLS)?
- CLS defines a subset of the Common Type System (CTS) that all .NET languages must follow to ensure cross-language compatibility.
- It provides a set of rules for data types and programming constructs that are guaranteed to work across different languages.
Example:
// CLS-compliant code: using standard types
public class SampleClass
{
public int Add(int a, int b)
{
return a + b;
}
}
13. What is Just-In-Time (JIT) Compilation?
- JIT Compilation is a process where the Intermediate Language (IL) code is converted to machine code at runtime.
- It helps optimize execution by compiling code only when it is needed, thus saving memory and resources.
Types of JIT Compilers:
- Pre-JIT: Compiles the entire code during deployment.
- Econo-JIT: Compiles only required methods, reclaims memory afterward.
- Normal JIT: Compiles methods when called for the first time.
14. What is the difference between Early Binding and Late Binding in .NET?
Early Binding:
- Happens at compile time.
- Compiler knows the method signatures and types in advance.
- Safer and faster.
Late Binding:
- Happens at runtime.
- Uses reflection to dynamically invoke methods and access types.
- Flexible but slower and prone to errors.
Example:
// Early binding
SampleClass obj = new SampleClass();
obj.PrintMessage();
// Late binding using reflection
Type type = Type.GetType("SampleClass");
object instance = Activator.CreateInstance(type);
MethodInfo method = type.GetMethod("PrintMessage");
method.Invoke(instance, null);
15. What is Garbage Collection (GC) in .NET?
- Garbage Collection is the process in the .NET Framework that automatically frees memory by reclaiming objects that are no longer in use.
- GC improves memory management by cleaning up unreferenced objects.
Generations in Garbage Collection:
- Generation 0: Short-lived objects.
- Generation 1: Medium-lived objects.
- Generation 2: Long-lived objects.
Example:
class Program
{
static void Main()
{
// Force garbage collection
GC.Collect();
GC.WaitForPendingFinalizers();
}
}
16. What is the difference between Dispose() and Finalize()?
Dispose():- Part of the IDisposable interface.
- Must be called explicitly to release unmanaged resources.
Finalize():- Called by the Garbage Collector before an object is destroyed.
- Cannot be called explicitly; handled by the system.
Example:
class MyClass : IDisposable
{
public void Dispose()
{
// Clean up unmanaged resources
}
~MyClass()
{
// Finalizer (destructor) called by GC
}
}
17. What is Reflection in .NET?
- Reflection allows programs to inspect and interact with object metadata at runtime.
- It can be used to dynamically create instances, invoke methods, and access fields and properties.
Example:
Type type = typeof(SampleClass);
object instance = Activator.CreateInstance(type);
MethodInfo method = type.GetMethod("PrintMessage");
method.Invoke(instance, null);
18. What is ADO.NET?
- ADO.NET is a data access technology used to interact with databases (SQL, Oracle, etc.) in the .NET Framework.
- It provides data connectivity between .NET applications and data sources, allowing you to execute SQL queries, stored procedures, and manage transactions.
Components of ADO.NET:
- Connection: Establishes a connection to the database.
- Command: Executes SQL statements.
- DataReader: Reads data from a data source in a forward-only manner.
- DataAdapter: Fills DataSet/DataTable with data.
- DataSet/DataTable: In-memory representation of data.
Example:
using (SqlConnection connection = new SqlConnection("connectionString"))
{
SqlCommand command = new SqlCommand("SELECT * FROM Students", connection);
connection.Open();
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
Console.WriteLine(reader["Name"]);
}
}
19. What is the difference between DataReader and DataSet in ADO.NET?
- DataReader:
- Provides forward-only, read-only access to data from a database.
- Faster and more memory-efficient.
- DataSet:
- In-memory representation of data that can be manipulated without being connected to the database.
- Slower, but supports multiple tables and relationships.
20. What is ASP.NET?
- ASP.NET is a web application framework developed by Microsoft for building dynamic web pages, websites, and web services.
- It provides tools and libraries for building web applications with features like state management, server controls, and web forms.
Types of ASP.NET Applications:
- Web Forms: Event-driven development model with server-side controls.
- MVC (Model-View-Controller): A design pattern separating data, UI, and logic.
- Web API: Used for building RESTful web services.
- Blazor: Allows building interactive web UIs using C# instead of JavaScript.
Example (Web Forms):
protected void Button_Click(object sender, EventArgs e)
{
Label.Text = "Hello, ASP.NET!";
}
21. What are HTTP Handlers and HTTP Modules in ASP.NET?
HTTP Handlers:
- Low-level components that process incoming HTTP requests directly.
- Typically used to handle requests for specific file types (e.g., .aspx, .ashx).
HTTP Modules:
- Intercepts and modifies requests/responses at various stages in the pipeline.
- Used for authentication, logging, or custom headers.
Example (Handler):
public class MyHandler : IHttpHandler
{
public void ProcessRequest(HttpContext context)
{
context.Response.ContentType = "text/plain";
context.Response.Write("Handled by MyHandler.");
}
public bool IsReusable => false;
}
22. What is the difference between Session and ViewState in ASP.NET?
- Session:
- Stores user-specific data on the server.
- Persists across multiple pages and requests within a session.
- Consumes more server resources (memory).
- ViewState:
- Stores data in a hidden field on the client (browser) side.
- Retains data only for a single page during postbacks.
- Increases page size but doesn’t use server memory.
Example of ViewState:
// Storing value in ViewState
ViewState["UserName"] = "John";
// Retrieving value from ViewState
string userName = ViewState["UserName"].ToString();
23. What is ASP.NET MVC?
- ASP.NET MVC is a web development framework that follows the Model-View-Controller design pattern.
- Model: Represents the application data and business logic.
- View: Displays the data and the user interface.
- Controller: Handles user input, updates the model, and selects a view to render.
Advantages:
- Separation of concerns.
- Easier unit testing.
- Greater control over HTML, CSS, and JavaScript.
Example:
public class HomeController : Controller
{
public ActionResult Index()
{
return View();
}
}
24. What are Action Filters in ASP.NET MVC?
- Action Filters allow you to execute code before or after an action method is executed.
- Common use cases include logging, authorization, and caching.
Types of Action Filters:
- Authorization Filters (e.g.,
Authorize). - Action Filters (e.g.,
OnActionExecuting, OnActionExecuted). - Result Filters (e.g.,
OnResultExecuting, OnResultExecuted). - Exception Filters (e.g.,
HandleError).
Example:
public class LogActionFilter : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext filterContext)
{
// Log before action executes
}
}
25. What is Entity Framework (EF)?
- Entity Framework is an Object-Relational Mapping (ORM) framework for .NET that allows developers to work with databases using .NET objects (classes) instead of writing SQL queries.
- Advantages:
- Automatic generation of database schema.
- Enables LINQ to query the database.
- Database migration support for schema changes.
Example:
// Defining a model
public class Student
{
public int ID { get; set; }
public string Name { get; set; }
}
// Using Entity Framework to interact with the database
using (var context = new SchoolContext())
{
var students = context.Students.ToList();
}
26. What is the difference between LINQ to SQL and Entity Framework?
- LINQ to SQL:
- Designed for direct database access with SQL Server.
- Supports a one-to-one mapping between database tables and .NET classes.
- Simpler but less feature-rich than Entity Framework.
- Entity Framework (EF):
- Provides more features such as inheritance, complex types, and multi-table mapping.
- Works with multiple database providers (SQL Server, MySQL, Oracle).
- Supports Code First, Database First, and Model First approaches.
27. What is Web API in ASP.NET?
- ASP.NET Web API is a framework for building HTTP-based services that can be consumed by a wide variety of clients (e.g., browsers, mobile devices).
- Web API is primarily used to create RESTful services, where HTTP verbs (GET, POST, PUT, DELETE) map to CRUD operations.
public class ProductsController : ApiController
{
public IEnumerable<Product> GetAllProducts()
{
return productList;
}
}
28. What is Dependency Injection (DI) in ASP.NET?
- Dependency Injection is a design pattern that allows injecting objects into a class, rather than creating objects inside the class.
- It decouples the creation of objects from the business logic, making the code more modular and testable.
Example (using ASP.NET Core DI):
public class HomeController : Controller
{
private readonly IProductService _productService;
public HomeController(IProductService productService)
{
_productService = productService;
}
public IActionResult Index()
{
var products = _productService.GetProducts();
return View(products);
}
}
29. What are REST and SOAP?
30. What is OAuth in ASP.NET?
- OAuth
is an open standard for token-based authentication, used to grant
third-party applications limited access to user resources without
exposing credentials.
- OAuth is commonly used in social logins (e.g., login with Google or Facebook).
31. What is SignalR in ASP.NET?
- SignalR is a library that allows real-time web functionality in ASP.NET applications.
- It enables the server to send updates to clients instantly via WebSockets, long-polling, or Server-Sent Events.
Use cases:
- Chat applications.
- Real-time notifications.
- Live data feeds.
Example:
public class ChatHub : Hub
{
public async Task SendMessage(string user, string message)
{
await Clients.All.SendAsync("ReceiveMessage", user, message);
}
}
32. What is NuGet in .NET?
- NuGet is a package manager for .NET, allowing developers to share and consume reusable code libraries.
- It simplifies the process of including third-party libraries into your project.
Example:
Install-Package Newtonsoft.Json
33. What are Generics in C#?
- Generics allow defining classes, interfaces, and methods with placeholders for data types.
- They promote code reusability and type safety by allowing you to create type-agnostic data structures.
Example:
public class GenericClass<T>
{
public T Data { get; set; }
}
34. What is a delegate in C#?
- Delegates are type-safe function pointers that allow methods to be passed as parameters.
- Useful in implementing callback functions, events, and asynchronous programming.
Example:
public delegate void DisplayMessage(string message);
public void ShowMessage(string message)
{
Console.WriteLine(message);
}
DisplayMessage display = new DisplayMessage(ShowMessage);
display("Hello, World!");
35. What are events in C#?
- Events provide a mechanism for a class to notify other classes or objects when something of interest occurs.
- Events are built on top of delegates and are typically used in UI programming and handling user interactions.
Example:
public event EventHandler ButtonClicked;
36. What are Extension Methods in C#?
- Extension Methods allow you to add new methods to existing types without modifying their source code or creating a derived type.
- Extension methods are static methods, but they are called as if they were instance methods on the extended type.
Syntax:
public static class StringExtensions
{
public static int WordCount(this string str)
{
return str.Split(' ').Length;
}
}
// Usage
string sentence = "Hello World";
int count = sentence.WordCount(); // Output: 2
Key Points:
- Defined in static classes.
- The first parameter specifies the type being extended, and the keyword
this is used before the type.
37. What is the difference between finalize and dispose methods?
Finalize:
- Called by the garbage collector before an object is destroyed.
- Used to release unmanaged resources.
- Cannot be called explicitly in code.
- Defined using a destructor in C#.
Dispose:
- Explicitly called by the developer to release unmanaged resources.
- Part of the
IDisposable interface. - Should be used when working with resources like file handles or database connections.
Example using Dispose:
public class ResourceHolder : IDisposable
{
private bool disposed = false;
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
// Free managed resources
}
// Free unmanaged resources
disposed = true;
}
}
~ResourceHolder()
{
Dispose(false);
}
}
38. What is the using statement in C#?
- The
using statement is used to automatically manage the disposal of unmanaged resources. - It ensures that
Dispose() is called on objects that implement IDisposable, even if an exception occurs.
Example:
using (var reader = new StreamReader("file.txt"))
{
string content = reader.ReadToEnd();
}
// `Dispose()` is automatically called on `StreamReader`.
39. What is a sealed class in C#?
- A
sealed class cannot be inherited by other classes. It restricts the class hierarchy by preventing inheritance. - Sealing a class can be useful for security, performance, or if you want to ensure the class’s implementation stays unchanged.
Example:
public sealed class SealedClass
{
public void Display()
{
Console.WriteLine("This is a sealed class.");
}
}
40. What is the lock statement in C#?
- The
lock statement
is used to ensure that a block of code is executed by only one thread
at a time. It provides thread-safety by preventing race conditions. - Typically used when working with shared resources in multi-threaded applications.
Example:
private static object _lock = new object();
public void CriticalSection()
{
lock (_lock)
{
// Code that must be synchronized
}
}
41. What are Indexers in C#?
- Indexers allow objects to be indexed like arrays. They enable a class to be accessed using square brackets
[], similar to array elements.
Example:
public class SampleCollection
{
private string[] elements = new string[100];
public string this[int index]
{
get { return elements[index]; }
set { elements[index] = value; }
}
}
// Usage
SampleCollection collection = new SampleCollection();
collection[0] = "First Element";
Console.WriteLine(collection[0]); // Output: First Element
42. What is the difference between Array and ArrayList in C#?
Array:
- Fixed size, strongly-typed (can only hold one data type).
- Faster performance due to strong typing.
ArrayList:
- Dynamic size, but not strongly-typed (can hold different data types).
- Uses more memory and is slower compared to arrays due to boxing and unboxing of value types.
Example:
// Array
int[] numbers = new int[5];
// ArrayList
ArrayList list = new ArrayList();
list.Add(1);
list.Add("String"); // Mixed types
43. What is a Multicast Delegate in C#?
- A Multicast Delegate can hold references to multiple methods. When invoked, it calls all the methods in its invocation list.
Example:
public delegate void Notify();
public class DelegateExample
{
public static void Method1() { Console.WriteLine("Method1"); }
public static void Method2() { Console.WriteLine("Method2"); }
public static void Main()
{
Notify notifyDelegate = Method1;
notifyDelegate += Method2; // Multicast
notifyDelegate.Invoke();
}
}
// Output:
// Method1
// Method2
44. What is the difference between IEnumerable and IQueryable in C#?
IEnumerable:
- Suitable for in-memory data collection.
- Queries are executed in memory.
- Supports LINQ to Objects and LINQ to XML.
IQueryable:
- Suitable for out-of-memory data (e.g., databases).
- Queries are executed on the data source (e.g., SQL database).
- Supports deferred execution and LINQ to SQL.
Example:
// Using IQueryable for deferred execution
IQueryable<Product> query = dbContext.Products.Where(p => p.Price > 50);
// Using IEnumerable
IEnumerable<Product> products = query.ToList();
45. What are anonymous methods in C#?
- Anonymous methods allow you to define inline, unnamed methods using the
delegate keyword. - They are used for shorter, simpler delegate expressions, and can capture variables from their surrounding scope.
Example:
Func<int, int> square = delegate (int x)
{
return x * x;
};
int result = square(5); // Output: 25
46. What are Lambda Expressions in C#?
- Lambda expressions are concise ways to write anonymous methods. They are used extensively in LINQ queries.
Example:
Func<int, int> square = x => x * x;
int result = square(5); // Output: 25
47. What is the role of yield in C#?
yield
allows methods to return elements of a collection one at a time,
without storing them all in memory. It's useful for creating custom
iterator methods.
Example:
public IEnumerable<int> GetNumbers()
{
for (int i = 1; i <= 5; i++)
{
yield return i;
}
}
// Usage
foreach (int number in GetNumbers())
{
Console.WriteLine(number);
}
48. What is Reflection in C#?
- Reflection allows inspecting and interacting with the metadata of types, methods, and properties at runtime.
Use cases:
- Creating objects dynamically.
- Invoking methods at runtime.
- Accessing private fields and methods.
Example:
Type type = typeof(MyClass);
MethodInfo method = type.GetMethod("MyMethod");
method.Invoke(Activator.CreateInstance(type), null);
49. What is the purpose of is and as operators in C#?
is: Checks if an object is of a specific type.as: Attempts to cast an object to a specific type, returning null if the cast fails.
Example:
object obj = "Hello";
if (obj is string)
{
string str = obj as string;
Console.WriteLine(str);
}
50. What is the out keyword in C#?
- The
out keyword allows a method to return multiple values by passing arguments by reference. - Parameters marked with
out must be assigned a value before the method returns.
Example:
public void GetValues(out int a, out int b)
{
a = 10;
b = 20;
}
// Usage
int x, y;
GetValues(out x, out y);
Console.WriteLine($"x = {x}, y = {y}");
51. What is a Strong Name in .NET?
- A Strong Name uniquely identifies an assembly using its name, version, culture, and public key token.
- Strongly named assemblies are stored in the GAC and help in avoiding conflicts between versions.
Example:
sn -k MyKey.snk
52. What is the difference between const and readonly in C#?
const:- Compile-time constant.
- Value cannot change.
- Must be assigned at declaration.
readonly:- Runtime constant.
- Can be assigned at runtime in the constructor.
Example:
const int maxItems = 100;
readonly int maxLimit;
53. What is the purpose of sealed methods in C#?
- A
sealed method is a method that prevents overriding in derived classes. - Only applies to methods in base classes marked
virtual or override.
Example:
public override sealed void Method()
{
// This method cannot be overridden further.
}
54. What is the difference between throw and throw ex in exception handling?
throw: Re-throws the original exception while preserving the stack trace.throw ex: Resets the stack trace, making it harder to trace the original error.
Example:
try
{
// Some code
}
catch(Exception ex)
{
throw; // Preserves original exception
}
55. What is the difference between Task and Thread in C#?
Task:
Higher-level abstraction for managing asynchronous operations. It
supports continuations and better integrates with async/await.Thread: Lower-level, represents a unit of execution in the system.
56. What is Lazy<T> in C#?
Lazy<T> provides a way to delay the initialization of an object until it is needed (lazy loading).
Example:
Lazy<MyClass> lazyObj = new Lazy<MyClass>(() => new MyClass());
57. What is the difference between Abstract Class and Interface in C#?
- Abstract Class:
- Can have method implementations.
- Supports access modifiers.
- Can contain constructors.
- Interface:
- Only method declarations (before C# 8.0).
- Cannot have access modifiers.
- No constructors.
58. What is the difference between synchronous and asynchronous programming?
- Synchronous:
- Blocking, one operation must complete before another can start.
- Asynchronous:
- Non-blocking, allows operations to run in parallel or independently.
Example:
await Task.Delay(1000); // Asynchronous call
59. What is the Func delegate in C#?
Func is a built-in delegate type that returns a value. It can take up to 16 input parameters.
Example:
Func<int, int, int> add = (x, y) => x + y;
60. What is the difference between String and StringBuilder?
String: Immutable, every change creates a new string object.StringBuilder: Mutable, optimized for multiple manipulations on strings.
61. What is the Singleton Design Pattern?
- The Singleton Pattern ensures that a class has only one instance and provides a global point of access to it.
Example:
public class Singleton
{
private static Singleton _instance;
private Singleton() { }
public static Singleton Instance => _instance ??= new Singleton();
}
62. What is Memory Leak in .NET and how to prevent it?
- A Memory Leak occurs when objects are no longer used but not freed, causing memory exhaustion.
- To prevent it:
- Dispose unmanaged resources properly.
- Use weak references where applicable.
- Implement the
IDisposable interface.
63. What is the difference between Task.Run() and TaskFactory.StartNew()?
Task.Run(): Suitable for CPU-bound operations and preferred for new code.TaskFactory.StartNew(): Offers more configuration options and is more flexible.
64. What is the volatile keyword in C#?
- The
volatile keyword
ensures that a variable's value is always read from memory, preventing
optimizations that might cache its value in CPU registers.
65. What is the difference between Task.Wait() and Task.Result?
Task.Wait(): Blocks the calling thread until the task completes.Task.Result: Blocks the thread and retrieves the task’s result.
66. What is the difference between a Shallow Copy and a Deep Copy?
- Shallow Copy: Copies the reference types as references (pointers).
- Deep Copy: Copies the actual objects, creating new instances.
67. What is the difference between a List<T> and an Array in C#?
List<T>: Dynamic size, resizable, part of System.Collections.Generic.- Array: Fixed size, cannot resize after creation.
68. What are Nullable Types in C#?
- Nullable types allow value types to have null values, using the
? syntax.
Example:
int? num = null;
69. What is the difference between First() and FirstOrDefault() in LINQ?
First(): Throws an exception if no element is found.FirstOrDefault(): Returns a default value (like null or 0) if no element is found.
70. What is yield in C#?
yield
is used to create an iterator block, returning each element of a
collection one at a time without creating the entire collection in
memory.
71. What are the differences between Task and ThreadPool?
- Task: Used for managing parallel code.
- ThreadPool: Manages a pool of worker threads to perform tasks.
72. What is the lock keyword in C#?
lock is used to ensure that a block of code runs exclusively in a multi-threaded environment, preventing race conditions.
73. What is IEnumerable<T> in C#?
IEnumerable<T> represents a forward-only, read-only collection of a sequence of elements.
74. What is Covariance and Contravariance in C#?
- Covariance allows a method to return a more derived type than the specified type.
- Contravariance allows a method to accept arguments of a more general type than the specified type.
75. What is a Mutex in .NET?
- A
Mutex is used for synchronizing access to a resource across multiple threads and processes.
76. What are Tuples in C#?
- A Tuple is a data structure that can hold multiple values of different types.
Example:
var tuple = Tuple.Create(1, "Hello", true);
77. What is the difference between ToString() and Convert.ToString()?
ToString(): Can throw an exception if the object is null.Convert.ToString(): Returns an empty string if the object is null.
78. What is the ThreadLocal<T> class in C#?
ThreadLocal<T> provides thread-local storage, meaning each thread has its own separate instance of a variable.
79. What is the ICloneable interface in C#?
- The
ICloneable interface provides a mechanism for creating a copy of an object.
80. What is the WeakReference class in C#?
- A WeakReference allows an object to be garbage collected while still allowing a reference to the object.
.png)
.png)
.png)
.png)
.png)
.png)
.png)
.png)