What is the difference between var and dynamic in c#

 
In C#, `var` and `dynamic` are both used for type inference, but they have different behaviors.

var is used for implicitly typed local variables, where the type is determined at compile-time based on the assigned value. Once the type is inferred, it is fixed, and the variable behaves like a statically typed variable.


var example = "Hello, World!"; // Compiler infers type as string


dynamic is a type that bypasses compile-time type checking and resolves types at runtime. It allows you to perform operations on objects without knowing their types at compile-time. However, this flexibility comes with a trade-off in performance and type safety.


dynamic example = "Hello, World!"; // Type is resolved at runtime


In summary, use var when you want the compiler to determine the type at compile-time with static typing, and use dynamic when you need runtime flexibility at the cost of type safety.

Comments

Post a Comment

Popular posts from this blog

Attribute-based routing in web api

Attribute-based routing is a feature in ASP.NET Web API (and ASP.NET Core MVC) that allows developers to define routes directly on controller actions or methods using attributes, rather than configuring routes in a centralized routing table. This approach enables developers to have more fine-grained control over routing, making the codebase more organized and easier to maintain. By decorating controller actions or methods with attributes like `[Route]`, `[HttpGet]`, `[HttpPost]`, `[HttpPut]`, `[HttpDelete]`, etc., developers can specify the HTTP method and route template for each action, directly within the controller itself. This approach simplifies routing configuration and makes it more intuitive, especially for RESTful APIs where HTTP methods have specific meanings. For example, in ASP.NET Core MVC, you can define routes like this: ```csharp-code [Route("api/[controller]")] public class ProductsController : ControllerBase {     [HttpGet]     public IActionResult ...
Read more

Garbage collection in C# with example

Image
Garbage collection in C# is the automatic process of managing memory by identifying and reclaiming objects that are no longer needed, freeing up memory for reuse. It helps prevent memory leaks and makes memory management more efficient. Here's a simple example: ```csharp class MyClass {     public int Data;          public MyClass(int value)     {         Data = value;     } } class Program {     static void Main()     {         MyClass obj1 = new MyClass(42); // Create an object         MyClass obj2 = new MyClass(84); // Create another object         // Now, let's assume we no longer need obj1         obj1 = null; // Set obj1 to null to indicate it's no longer referenced         // At this point, the garbage collector may identify obj1 as unreachable         // a...
Read more

What is managed code and unmanaged code in c# with example

Image
Managed code and unmanaged code are terms used in the context of C# and the .NET framework to describe how the code is executed and managed by the runtime environment. Here's an explanation and an example of each: 1. Managed Code:    - Managed code refers to code that is executed within the .NET Common Language Runtime (CLR) environment. The CLR provides various services such as memory management, type safety, and garbage collection.    - C# code is typically considered managed code because it is compiled into an intermediate language (IL) that is executed by the CLR.    Example of managed code in C#:    ```csharp    using System;    class Program    {        static void Main()        {            Console.WriteLine("This is managed code executed by the CLR.");        }    }    ``` 2. Unmanaged Code...
Read more