In ASP.NET MVC, passing data from a controller to a view is a fundamental aspect of the framework. This allows you to display dynamic content based on the application's state. There are several ways to pass data from a controller to a view, including using ViewData, ViewBag, TempData, and strongly typed models. Below, we will explore each method in detail with sample code.

1. Using ViewData

ViewData is a dictionary object that allows you to pass data from a controller to a view using key-value pairs. It is a dynamic way to pass data but does not provide compile-time checking.

        
        public class ProductController : Controller
        {
            public ActionResult Index()
            {
                ViewData["Message"] = "Welcome to the Product List!";
                return View();
            }
        }
            

In the example above, we set a message in the ViewData dictionary. To access this data in the view, you can use the following code:

        
        <h2>@ViewData["Message"]</h2>
            

2. Using ViewBag

ViewBag is a dynamic wrapper around ViewData that provides a more convenient way to pass data. It uses the dynamic feature of C# and allows you to access properties without needing to cast them.

        
        public class ProductController : Controller
        {
            public ActionResult Index()
            {
                ViewBag.Message = "Welcome to the Product List!";
                return View();
            }
        }
            

In the view, you can access the ViewBag property like this:

        
        <h2>@ViewBag.Message</h2>
            

3. Using TempData

TempData is used to pass data between actions. It is useful for scenarios where you want to redirect from one action to another and still retain the data. TempData uses session storage to hold the data temporarily.

        
        public class ProductController : Controller
        {
            public ActionResult Create()
            {
                TempData["SuccessMessage"] = "Product created successfully!";
                return RedirectToAction("Index");
            }

            public ActionResult Index()
            {
                ViewBag.Message = TempData["SuccessMessage"];
                return View();
            }
        }
            

In this example, we set a success message in TempData in the Create action and then access it in the Index action. In the view, you can display the message like this:

        
        <h2>@ViewBag.Message</h2>
            

4. Using Strongly Typed Models

The most common and recommended way to pass data from a controller to a view is by using strongly typed models. This approach provides compile-time checking and IntelliSense support in Visual Studio.

        
        public class Product
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public decimal Price { get; set; }
        }

        public class ProductController : Controller
        {
            public ActionResult Index()
            {
                var products = new List<Product>
                {
                    new Product { Id = 1, Name = "Product 1", Price = 10.00M },
                    new Product { Id = 2, Name = "Product 2", Price = 20.00M }
                };
                return View(products);
            }
        }
            

In the example above, we create a Product model and pass a list of products to the view. To create a strongly typed view, you would specify the model type at the top of the view:

        
        @model IEnumerable<Product>

        <h2> Product List</h2>
        <table>
            <thead>
                <tr>
                    <th>Id</th>
                    <th>Name</th>
                    <th>Price</th>
                </tr>
            </thead>
            <tbody>
                @foreach (var product in Model)
                {
                    <tr>
                        <td>@product.Id</td>
                        <td>@product.Name</td>
                        <td>@product.Price</td>
                    </tr>
                }
            </tbody>
        </table>
            

In this example, the view is strongly typed to IEnumerable<Product>, allowing you to access the properties of the Product model directly within the view.

Conclusion

Passing data from a controller to a view in ASP.NET MVC can be accomplished using various methods, including ViewData, ViewBag, TempData, and strongly typed models. While all methods are valid, using strongly typed models is the most recommended approach due to its advantages in type safety and IntelliSense support. By understanding these methods, developers can effectively manage data flow in their ASP.NET MVC applications.