It is not a straightforward version bump to upgrade an ASP.NET MVC application from the.NET Framework to the current.NET. The runtime, hosting model, configuration system, dependency injection, and HTTP pipeline architecture have all changed as a result of this migration. Many teams undervalue this and handle it like a typical framework upgrade, only to find out later on that their application's fundamental presumptions are no longer valid.

The good news is that Microsoft provides clear guidance and patterns that make this migration predictable when approached correctly. This article walks through a practical, step by step strategy to migrate an ASP.NET MVC 5 application built on .NET Framework to ASP.NET Core running on modern .NET, while minimizing risk and downtime.

This guide is written for developers who already understand ASP.NET MVC and want a realistic, production ready path forward.

Step 1: Choose your migration path based on app size

• Pick one of these two paths

• Incremental migration for most real apps
  You stand up a new ASP.NET Core app in front of the old app and move routes and features over gradually, keeping the old app live while you migrate. Microsoft recommends this approach for large migrations.
• Big bang migration for small apps 
  You create a new ASP.NET Core MVC app and port controllers, views, and services until everything runs, then you cut over.

If you are unsure, default to incremental migration because it reduces cutover risk.

Step 2: Inventory what will block you
List dependencies and app features that commonly need work during migration

• System.Web usage
  Things like HttpContext.Current, HttpModules, HttpHandlers, Global.asax, and classic pipeline features do not carry over as is.
• Authentication and authorization
  ASP.NET Core uses a different model.
• Session, caching, config, logging
  APIs and patterns differ and need deliberate migration planning.

Make a quick compatibility pass on your NuGet packages

• For each package, check if it supports netstandard2.0 or modern net versions, or if there is an ASP.NET Core replacement.
• Flag anything tied to System.Web.

Step 3: Create a safe baseline before touching code

• Freeze the current state
  • Tag the repo.
  • Ensure you can build the solution and run your test suite.

• Add or strengthen tests if you are light on coverage
  • Focus on critical routes, auth flows, and the top business actions.
  • If you cannot add tests quickly, at minimum record smoke test scripts and expected outputs.

Step 4: Upgrade libraries first, before the web app
This is the highest leverage move.
Split your solution into layers, if it is not already

Web project, application services, domain, data access, shared utilities.

Port class libraries first

Convert libraries to target netstandard2.0 when possible as a bridge, or target modern .NET directly if you can.

Fix compile errors and replace unsupported APIs.

Microsoft’s general porting guidance is to assess the project and move pieces in a way that reduces complexity after the initial upgrade.

Step 5: Decide whether to use migration tooling
You have two Microsoft supported tool directions you can use to speed up parts of the work.

• .NET Upgrade Assistant
  It helps upgrade projects and analyze incompatibilities, including .NET Framework projects. Use it where it helps, but do not expect it to fully transform an ASP.NET MVC 5 app into ASP.NET Core MVC automatically.

• Migration tooling for ASP.NET Framework apps
  Microsoft points to dedicated modernization tooling for upgrading ASP.NET Framework MVC, Web API, and Web Forms projects to ASP.NET Core.

You can still do everything manually if you prefer, but tooling can reduce boring mechanical edits.

Step 6: Create the new ASP.NET Core MVC host app
This step is required even in incremental migration because you need an ASP.NET Core app to run on modern .NET.

Create a new ASP.NET Core MVC project

• Use the standard ASP.NET Core MVC template.
• Add your core packages, logging, config, and DI structure.

Set up the modern entry point

• In ASP.NET Core, Program.cs configures the host and middleware pipeline.
• There is no Global.asax.

Add basic middleware you will definitely need

• Routing
• Static files
• Authentication and authorization, if applicable
• MVC endpoints

Minimal example shape:
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Step 7: Move routes first, then controllers, then views
Microsoft’s MVC to Core example walkthrough starts with setup, then controllers and views, then static content and client dependencies. Follow that order because it keeps the migration testable at every step.

Migrate routing

• In MVC 5 you likely used RouteConfig and possibly attribute routes.
• In ASP.NET Core you configure routing in the middleware pipeline and endpoint mappings.

Migrate one controller at a time

• Copy a controller class.
• Fix compile errors by switching namespaces and replacing System.Web dependent code.
• Replace HttpContext.Current patterns with controller HttpContext access.

Migrate views

• Razor syntax is similar, but helpers and some features differ.
• Convert HTML helpers where needed, and use Tag Helpers where it makes sense.

Migrate partials, layouts, and shared view imports

• You will likely introduce ViewImports.cshtml and ViewStart.cshtml patterns.

Step 8: Move static files and client side dependencies

• Static files
  • In MVC 5 you may have used Content and Scripts conventions.
  • In ASP.NET Core, the default is wwwroot plus UseStaticFiles middleware.
• Bundling and minification
  If you relied on System.Web.Optimization, replace it with a modern frontend build pipeline or another supported approach.

Microsoft’s example migration flow explicitly calls out static content and client side dependencies as an early migration step.

Step 9: Migrate configuration from Web.config to appsettings

• Identify what you store in Web.config
  • Connection strings
  • App settings
  • Authentication settings
  • Custom config sections
• Move settings into appsettings.json and environment specific appsettings files
• Read settings using the ASP.NET Core configuration system via builder.Configuration

Microsoft has dedicated guidance linked from the MVC migration example for migrating configuration.

Step 10: Migrate authentication and authorization
Identify your current auth model

• Forms auth
• OWIN cookies
• ASP.NET Identity in MVC 5
• Windows auth

Implement the equivalent in ASP.NET Core

• Configure authentication services in DI.
• Add middleware in the pipeline.
• Port authorization attributes and policies.

Microsoft’s MVC migration example points to dedicated guidance for migrating authentication and Identity because it is usually one of the heavier parts.

Step 11: Migrate data access
If you use Entity Framework 6

• You can often keep EF6 for a while, even on modern .NET, depending on your setup.
• Longer term, many teams move to EF Core for modern patterns and features.

If you use ADO.NET or Dapper
These typically port cleanly, but you will update configuration and dependency injection patterns.

Step 12: Run the app, fix runtime issues, then optimize

Build and run locally

Fix runtime issues in this typical order

    Configuration and environment differences

    Middleware ordering problems

    Auth and cookies

    Session and caching behavior

Run automated tests and smoke tests

Add structured logging and health checks where appropriate

Step 13: If you chose incremental migration, set up the “front door” Core app

For incremental migration, the key move is putting an ASP.NET Core app in front of the existing .NET Framework app and migrating route by route. Microsoft’s “get started” guidance for incremental migration recommends this proxy front approach for large migrations.

Your process becomes:

Route A handled by ASP.NET Core, everything else proxies to MVC 5

Move one vertical slice at a time

When all routes are moved, retire the old MVC 5 app

Step 14: Production cutover checklist

Hosting
Decide IIS in process, IIS out of process, or container.

Observability
Logs, metrics, tracing aligned across both apps during incremental migration.

Security
Cookie settings, data protection keys, TLS, headers

Performance
Confirm caching and session behavior after migration.

Final Thoughts
Migrating an ASP.NET MVC application from .NET Framework to modern .NET is a strategic investment, not a mechanical upgrade. When done correctly, it results in a cleaner architecture, improved performance, better cloud readiness, and long term platform support.By breaking the migration into deliberate, testable steps and focusing first on architecture rather than syntax, teams can modernize confidently without disrupting production systems.

This approach has proven to work repeatedly in real world enterprise migrations and aligns with Microsoft’s recommended modernization strategy for ASP.NET applications.

This article describes how to use contemporary APIs (OpenAI, Azure OpenAI, Hugging Face, and Self-hosted LLMs) to integrate AI agents with ASP.NET MVC.

What Is an AI Agent?

• An AI Agent is an autonomous component capable of:
• Understanding user input
• Taking decisions
• Calling tools (APIs, DB, services)
• Updating its memory
• Producing actions or responses
• Triggering workflows

In an MVC project, an AI Agent often acts as:

• Chatbot
• Automated email writer
• Code generator
• Ticket classification bot
• Data extraction worker
• Knowledge base assistant

Project Structure (MVC)
Your MVC app will use:
Controllers/
    AiAgentController.cs
Services/
    AiAgentService.cs
Models/
    AiRequest.cs
    AiResponse.cs
Views/
    AiAgent/
        Index.cshtml

Step 1: Install Required Nuget Packages
For OpenAI-compatible agents:
Install-Package OpenAI
Install-Package Newtonsoft.Json

Step 2: Create Your AI Agent Service (Backend Logic)
Create: Services/AiAgentService.cs
using OpenAI.Chat;
using OpenAI;
using System.Threading.Tasks;

namespace YourApp.Services
{
    public class AiAgentService
    {
        private readonly OpenAIClient _client;

        public AiAgentService(string apiKey)
        {
            _client = new OpenAIClient(apiKey);
        }

        public async Task<string> AskAgentAsync(string userInput)
        {
            var chat = _client.GetChatClient("gpt-4o-mini");

            var response = await chat.CompleteAsync(
                userInput
            );

            return response.Content[0].Text;
        }
    }
}

Step 3: Add the Service to Dependency Injection
Open Global.asax.cs (or Program.cs for .NET 6+ MVC)
For .NET 4.8 MVC
In UnityConfig.cs or Autofac:
container.RegisterType<AiAgentService>(
    new InjectionConstructor("YOUR_OPENAI_API_KEY")
);

For .NET 6/7 MVC
Program.cs
builder.Services.AddSingleton<AiAgentService>(new AiAgentService("YOUR_API_KEY"));

Step 4: Create Controller to Call the AI Agent
Controllers/AiAgentController.cs

using System.Threading.Tasks;
using System.Web.Mvc;
using YourApp.Services;

namespace YourApp.Controllers
{
    public class AiAgentController : Controller
    {
        private readonly AiAgentService _ai;

        public AiAgentController(AiAgentService ai)
        {
            _ai = ai;
        }

        [HttpGet]
        public ActionResult Index()
        {
            return View();
        }

        [HttpPost]
        public async Task<ActionResult> Index(string userMessage)
        {
            var aiResponse = await _ai.AskAgentAsync(userMessage);
            ViewBag.Response = aiResponse;
            return View();
        }
    }
}

Step 5: Create Razor View for Chat UI
Views/AiAgent/Index.cshtml
@{
    ViewBag.Title = "AI Agent Chat";
}

<h2>AI Agent in MVC</h2>

<form method="post">
    <textarea name="userMessage" class="form-control" rows="4" placeholder="Ask anything..."></textarea>
    <br />
    <button class="btn btn-primary">Send</button>
</form>

@if (ViewBag.Response != null)
{
    <div class="alert alert-info" style="margin-top:20px;">
        <strong>AI Agent Reply:</strong>
        <p>@ViewBag.Response</p>
    </div>
}

Your First AI Agent Is Ready
You can now run:
/AiAgent/Index

Type a message:
    “Summarize this text”

    “Generate email template for refund request”

    “Write C# code for a stored procedure call”

    “Fix my SQL query”

The agent instantly responds.

Advanced: Add Tools (Function Calling)
Agents become powerful when they can call functions inside your MVC app.
Example: Agent gets order status from your database.

Step 1: Add a Tool Method
public string GetOrderStatus(int orderId)
{
    return "Order " + orderId + " is in Packaging Stage.";
}

Step 2: Expose Tool to Agent
Most AI SDKs support function-calling like:
var response = await chat.CompleteAsync(
    messages: userInput,
    functions: new[]
    {
        new FunctionDefinition(
            "get_order_status",
            "Get order status using order ID",
            new { orderId = "number" }
        )
    });

Result:
Agent decides to call your function → Your C# method runs → Response returned back.

Real-World AI Agent Use Cases in MVC
1. Customer Support Assistant
Automatically understands user message → replies or creates ticket.

2. Form Auto-Generation
User describes what form they need → agent builds HTML form dynamically.

3. Code Generator Inside Admin Panel
Generate C# classes, views, DB queries on the fly.

4. Workflow Automation
User enters command → agent runs server-side tasks.

5. Knowledge Base Search Agent
AI agent + vector database → semantic search.

Advanced: Adding Memory to AI Agent
Short-term memory → history stored in session
Long-term memory → store in DB or vector DB (like Qdrant, Pinecone)

Session["history"] += userMessage + aiResponse;

Performance Tips & Best Practices

• Cache frequently used prompts

Use IMemoryCache or Redis

• Avoid sending huge previous chat

Compress or summarize conversation

• Always use streaming for faster response

Most SDKs support streaming tokens

• Background agents for heavy tasks

Use IHostedService or Windows Service

Common Mistakes Developers Make

Final Thoughts
AI Agents will become a core part of all ASP.NET MVC applications.
With just a few steps, you can:

• Add smart chatbots
• Automate workflows
• Enhance admin panels
• Add dynamic intelligence
• Build modern AI-driven enterprise apps

Here, we'll discover how to use our ASP.NET MVC application's Facebook login. These days, every commercial website has an external login feature that allows users to log in using social media sites like Facebook, Google, Twitter, and others. similar to Amazon and Flipkart.

We will now learn how to provide a Facebook login.

Click "New Project" in Visual Studio. A window will then appear. Choose "Asp.net MVC4 web application" and give it a name (in my example, "FacebookLoginMVCApplication").

Now click ok and select a template as Internet Application and engine as Razor engine, after sleeting all these click ok. It will click a solution project this will contain .Css file ,script file and MVC application structure.

After creation of application let's create a database for this and give the name for this database i gave it as 'MVCApp' and then add a connection string to the database.
    <connectionStrings>  
        <add name="DefaultConnection" connectionString="Data Source=MUNESH-PC;Database=MVCApp;UID=sa;Password=*****" providerName="System.Data.SqlClient" />  
    </connectionStrings>  

If you are creating a new connection string then existing connection string in ewb config file we have removed the following line of code from the "InitializeSimpleMembershipAttribute.cs" which is available in filter folder because it gives a double connection existing run time error.
    // WebSecurity.InitializeDatabaseConnection("DefaultConnection", "UserProfile", "UserId", "UserName", autoCreateTables: true);  

After adding the connection string to the project now we need to create membership tables to the database but before this go to the models folder and have a look on AccountModels.cs class. This class is automatically created when we select mvc application as Internet application.

AccountModel.cs class contain following methods.

Now for creating membership tables in database initialize the connection in globel.asax. Here we will use code first approach for that we need to add following code in this class.

For adding data table in database membership we need to add a line of code in Global.asax.
    WebSecurity.InitializeDatabaseConnection("DBConnection", "UserProfile", "UserId", "UserName", autoCreateTables: true);  

Here namespace for WebSecurity is “using WebMatrix.WebData;”

WebSecurity.InitializeDatabaseConnection
Definition for the InitializeDatabaseConnection is,
    public static void InitializeDatabaseConnection (string connectionStringName, string userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables);  

connectionStringName - It the name of database table where user information stored.

UserTableName - It contains user profile information.

UserIdColumn - This column name of table contains user ID this should be integer.

UserNameColumn
Column name of table contains user name. This column is basically used to match profile data of user with membership account data.

AutoCreateTables 
True to indicate that user profile and membership tables should be created if they do not exist; false to indicate that tables should not be created automatically. Although the membership tables can be created automatically, the database itself must already exist.

Now globel.asax page will look like.

Now after all this configuration let's run your application and see the url home page and click on register link which is your page right side. After running your application you go to database and see the table, it will generate following tables for us,

AuthConfig file in Asp.net MVC application
This AuthConfig file is exist under “App_start”s folder. It is automatically created by the asp.net mvc application when we create a project.
This AuthConfig.cs file contains the entire external client as comment by default. So we need to uncomment for auth config for faceBook then the code we like following.

At this time if you will run your application it will give error that you can’t be put empty value for “appID,secreted”. For that we need to register in facebook.

Register MVC application with facebook
Before running mvc application we have to pass appID and secret id so for that we need to register in facebook or login if you have account in facebook, after loggin in go to the URL and register there. There will be register button at right click side at top.

After registering you need to create Appid for your website, it will redirect to that page after registering or you can go to this URL and fill the information which it is asking like the following snapshot. From here click on create new App id it will open a window.
  
There I gave display name as "dotnet" and Email and category I selected as “Education and after that click on create App ID. After click on this, your account will be created and it will redirect to the following page where it will ask security answer for selecting image,

From here you have to select Website. After selecting add platform a small panel will popup asking Site URL here you will be adding your project URL like http://localhost:63695/.To see where project URL is just right click on Project then select Properties like as shown below.

After selecting Properties a new window will open inside that select Web Menu just below Build at bottom of page you will see Project URL which we highlighted in yellow here project URL like http://localhost:63695/.Just copy that URL.

After selecting click ok then a window will open. Here you can see your app id and Appsecret on Dashboard section. Now go to setting and on basic section enter field  and app domain as empty after that click on add platform and select website. When you will click on add flat form following window will open.

After copying just paste that URL inside Site URL (http://localhost:63695/) and then click on save changes button. After that just copy App ID and App Secret and just add in AuthConfig.cs files.

After adding just save your application then Run application. Following is our login page after adding oAuth facebook login in ASP.NET MVC application.

Here you will see a Facebook button on right part of login page. Now just click on this Facebook button then it will redirect you to Facebook login page ,here you enter Facebook credentials and then login in to Facebook. After logging in in to Facebook now a new dialog will pop up for allowing App to take your all profile information which you provided in facebook (like name, profile picture, age range, gender etc). Now just click on Okay button to proceed further. After clicking on okay button it will redirect to "ExternalLoginCallback" view and on that page we will see Username textbox which contains Username which we have got from Facebook Oauth service. now just click on Register button and you are logged in to your web application. The user name with facebook is successfully saved in UserProfile table and second table which iswebpages_OAuthMembership table.

Images play a major role in modern web applications, including dynamic content portals, product pages, and blogs. However, creating quality alt text and captions for each uploaded image is frequently a laborious, tedious process. An uploaded image can be automatically analyzed by the AI to produce:

• A meaningful, context-aware caption
• SEO-friendly alt text
• Multiple variations for each
• Output in any language

This article shows you how to integrate Gemini AI into ASP.NET Core MVC (.NET 10) to process images and generate high-quality descriptive text.

Why Use Gemini AI for Image Captioning?
Gemini AI is trained on a massive multimodal dataset, which means:

• It understands visual context (objects, scenes, emotions, actions)
• It can generate human-like captions
• It supports multiple languages
• It can return multiple options so users can choose the best one

Features We Will Implement

• Upload an image in ASP.NET Core MVC
• Send the image bytes to Gemini AI
• Ask Gemini to generate:
  • Multiple caption options
  • Multiple alt text variations
  • Output in multiple languages
• Render results on the page
• SEO-friendly and accessible output

Before diving into the code, first you have to create a project in Visual Studio (2026 prefer) and have a Gemini API key that you can get it from Google AI Studio .

Project Structure
Below image shows the project structure that I am following to demonstrate the implementation.

Add Gemini API Key to appsettings.json
{
  "Gemini": {
    "ApiKey": "your-api-key-here"
  }
}

You can store the API key in User Secrets for security.
Create the Image Upload View
<div class="container mt-5">
    <div class="card shadow p-4">
        <h2 class="mb-4 text-center">AI Image Caption Generator</h2>
        <form asp-action="Analyze" enctype="multipart/form-data" method="post">
            <div class="mb-3">
                <label class="form-label">Select Image</label>
                <input type="file" name="file" class="form-control" required />
            </div>
            <div class="mb-3">
                <label class="form-label">Select Language</label>
                <select name="language" class="form-select">
                    <option value="en">English</option>
                    <option value="ne">Nepali</option>
                    <option value="hi">Hindi</option>
                    <option value="es">Spanish</option>
                    <option value="fr">French</option>
                    <option value="ja">Japanese</option>
                </select>
            </div>
            <button class="btn btn-primary w-100">Analyze Image</button>
        </form>
    </div>
</div>

Create the Service to Handle Gemini Connection
This GeminiService is responsible to handle connection with the Gemini AI API with the prompt. Uploaded image converts into the base64Image as Geimin AI requires base64Image.
public class GeminiService
{
    private readonly IConfiguration _config;
    private readonly IHttpClientFactory _httpClientFactory;

    public GeminiService(IConfiguration config, IHttpClientFactory httpClientFactory)
    {
        _config = config;
        _httpClientFactory = httpClientFactory;
    }

    public async Task<(List<string> captions, List<string> alts)>
        AnalyzeImageAsync(byte[] imageBytes, string mimeType, string language = "English")
    {
        string apiKey = _config["Gemini:ApiKey"];
        if (string.IsNullOrEmpty(apiKey))
            throw new Exception("Gemini API Key missing");
        var http = _httpClientFactory.CreateClient();
        string base64Image = Convert.ToBase64String(imageBytes);
        var requestBody = new
        {
            contents = new[]
            {
            new {
                parts = new object[]
                {
                    new { text =
                        $"Analyze this image and return:" +
                        $"\n - 5 caption options" +
                        $"\n - 5 alt text options" +
                        $"\n - Language: {language}" +
                        $"\nRespond in JSON only: {{ \"captions\": [...], \"alts\": [...] }}"
                    },
                    new {
                        inline_data = new {
                            mime_type = mimeType,
                            data = base64Image
                        }
                    }
                }
            }
        }
        };
        string url =
            $"https://generativelanguage.googleapis.com/v1/models/gemini-2.5-flash:generateContent?key={apiKey}";
        var response = await http.PostAsync(
            url,
            new StringContent(JsonSerializer.Serialize(requestBody), Encoding.UTF8, "application/json")
        );

        if (!response.IsSuccessStatusCode)
        {
            string error = await response.Content.ReadAsStringAsync();
            throw new Exception($"Gemini API Error: {error}");
        }

        var json = await response.Content.ReadFromJsonAsync<JsonElement>();
        var textResponse = json
            .GetProperty("candidates")[0]
            .GetProperty("content")
            .GetProperty("parts")[0]
            .GetProperty("text")
            .GetString();

        textResponse = textResponse.Replace("```json", "").Replace("```", "");
        var resultJson = JsonDocument.Parse(textResponse).RootElement;
        var captions = resultJson.GetProperty("captions")
            .EnumerateArray().Select(x => x.GetString()).ToList();

        var alts = resultJson.GetProperty("alts")
            .EnumerateArray().Select(x => x.GetString()).ToList();

        return (captions, alts);
    }
}

Register GeminiService
In the program.cs file, add below lines of code to register HttpClient and GeminiService.
// Register HttpClient and GeminiService
builder.Services.AddHttpClient();
builder.Services.AddSingleton<GeminiService>();

Create a Controller
When the user uploads an image, the ImageController processes the form submission, converts the file into bytes, detects its MIME type, and sends the prepared image data to the GeminiService for further processing by Gemini AI.
public class ImageController: Controller
{
    private readonly GeminiService _gemini;

    public ImageController(GeminiService gemini)
    {
        _gemini = gemini;
    }

    public IActionResult Index() => View();

    [HttpPost]
    [RequestSizeLimit(10 * 1024 * 1024)] // 10 MB
    public async Task<IActionResult> Analyze(IFormFile file, string language = null)
    {
        if (file == null || file.Length == 0)
        {
            ModelState.AddModelError("file", "Please select an image file.");
            return View("Upload");
        }

        using var ms = new MemoryStream();
        await file.CopyToAsync(ms);
        var bytes = ms.ToArray();

        var result = new ResponseModel();
        try
        {
            var mimeType = MimeTypeHelper.GetMimeType(file.FileName);
            var content = await _gemini.AnalyzeImageAsync(bytes, mimeType, language);
            result.Alts = content.alts;
            result.Captions = content.captions;
        }
        catch (Exception ex)
        {
            //error handling
            TempData["Error"] = "Failed to analyze the uploaded image. Error: " + ex.Message;
            return RedirectToAction("Upload");
        }

        // Pass model to view
        return View("Result", result);
    }
}

Create the Result View
@using ImageAnalyzer.Models
@model ResponseModel
@{
    ViewData["Title"] = "AI Result";
}
<div class="container mt-5">
    <div class="card shadow p-4">
        <h2 class="mb-4 text-center">AI Generated Caption & Alt Text</h2>
        @if(Model.Alts.Any())
        {
            <h3>Suggested Alt text</h3>
            <ul>
                @foreach(var alt in Model.Alts)
                {
                    <li>@alt</li>
                }
            </ul>
        }

        @if(Model.Captions.Any())
        {
            <h3>Suggested Captions</h3>
            <ul>
                @foreach(var caption in Model.Captions)
                {
                    <li>@caption</li>
                }
            </ul>
        }

        <a href="/image" class="btn btn-secondary mt-3">Analyze Another Image</a>
    </div>
</div>

SEO Benefits
Using AI-generated caption & alt text improves:

• Google Image Search ranking
• Accessibility score
• User engagement
• Localized content reach
• Content creation time

Your editors no longer need to write text manually—AI does it instantly.

Conclusion
Using Gemini AI to automate alt text and image captions in ASP.NET Core MVC is:

• Easy to execute
• Excellent for SEO
• Beneficial to accessibility
• Very efficient in terms of time
• Supports all required languages.

Your program may automatically describe every uploaded image with a few lines of code, adding richness, intelligence, and user-friendliness to the material.

Model-View-Controller is a potent design used by ASP.NET Core MVC, where each component has a distinct role:

• Controller → Handles requests
• View (.cshtml) → Displays UI
• Model → Carries data

  

One common question for beginners is:
How does a .cshtml View know which controller it belongs to?

The simple answer is:

• Views never call controllers.
• Controllers call the views.

Let's break this down step-by-step.

1. MVC Routing: The Real Connection Between Controller and View
ASP.NET Core uses a default routing pattern:
/{controller}/{action}/{id?}
This means:

• The first part of the URL selects the controller
• The second part selects the action method inside that controller
• The view is determined by the action method

Example URL
/Account/Login

Meaning:

So when you open that URL, the framework:

• Finds AccountController
• Executes Login()
• Returns Login.cshtml

2. How Controllers Return Views
Inside a controller, you normally write:
public IActionResult Login()
{
return View();
}

When ASP.NET Core sees return View();, it looks for a .cshtml file that matches the action method name.

In this case:
Controller name → AccountController
Action method → Login()

So MVC loads the file here:

• Views/Account/Login.cshtml
• This is how the connection is made.

3. The View Folder Naming Convention
The MVC folder structure is very important:

Views
└── Account
    └── Login.cshtml

Rule 1 — Folder name = Controller name (without "Controller")
Controller: HomeController → Folder: Views/Home/
Controller: ProductController → Folder: Views/Product/

Rule 2 — View file name = Action method name
Action: Index() → View: Index.cshtml
Action: Details() → View: Details.cshtml

4. What If You Want to Load a Different View?
You can specify a different file name:
return View("CustomPage");

This loads:
Views/Account/CustomPage.cshtml

5. Shared Views
Sometimes you want a view that multiple controllers can use.

ASP.NET Core will look second in:
Views/Shared/

For example:
Views/Shared/Error.cshtml

6. Summary Diagram
User enters URL → MVC Routing → Finds Controller → Runs Action → Returns View (.cshtml)

Or visually:
/Account/Login
  ↓
AccountController
  ↓
Login() action
  ↓
Views/Account/Login.cshtml

Final Thoughts
The connection between .cshtml and controller is not magic —
it is handled through:

• Routing
• Folder naming conventions
• Action method names
• Return View() method

Once you understand this, the entire MVC workflow becomes easy.

Unexpected issues that impact functionality, performance, or user experience might occasionally arise when a ASP.NET MVC website is run in production. Any ASP.NET MVC developer must be able to diagnose and fix mistakes efficiently, regardless of whether they are runtime exceptions, deployment failures, or configuration issues. This article covers the most typical causes, tools, and recommended practices for troubleshooting issues in ASP.NET MVC applications.

<system.web>
  <customErrors mode="Off"/>
  <compilation debug="true"/>
</system.web>

• customErrors = Off shows full error details.
• debug = true provides a stack trace.
• Do NOT enable these in production.

Step 2: Check the Event Viewer Logs
If your MVC site is hosted on IIS, Windows Event Viewer is a great place to find exception logs.

Open Event Viewer

• Navigate to Windows Logs > Application
• Look for .NET Runtime or Application Error
• This helps identify runtime crashes and application pool failures.

Step 3: Use Try-Catch and Global Error Handling
Catch unhandled errors globally using Application_Error in Global.asax or a custom filter.

Global.asax
protected void Application_Error()
{
    var exception = Server.GetLastError();
    // Log the exception
    System.Diagnostics.Trace.TraceError(exception.ToString());
}

Custom HandleErrorAttribute
public class CustomErrorHandler : HandleErrorAttribute
{
    public override void OnException(ExceptionContext filterContext)
    {
        // Log exception here
        base.OnException(filterContext);
    }
}

Register in FilterConfig.cs:
filters.Add(new CustomErrorHandler());

Step 4: Check IIS Configuration and Permissions
Common IIS issues:

Step 5: Debug Route Errors

Wrong URL routing can lead to 404 errors.

Use this debugging helper:
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.MapRoute(
    name: "Default",
    url: "{controller}/{action}/{id}",
    defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);

Also check:

• Missing controllers/actions
• Incorrect parameter names
• Route conflicts

Step 6: Troubleshoot Dependency and DLL Issues
Example runtime error:
Could not load file or assembly 'Newtonsoft.Json'

Solutions:

• Check bin folder for missing DLLs
• Install via NuGet:
• Install-Package Newtonsoft.Json
• Ensure Copy Local = true for references

Step 7: Log Exceptions Using Logging Tools
Instead of relying on console logs, use structured logging:

• NLog
• Serilog
• Elmah (popular for MVC)

Example with NLog:
private static readonly Logger logger = LogManager.GetCurrentClassLogger();

try
{
    // some logic
}
catch(Exception ex)
{
    logger.Error(ex);
}

Step 8: Debug Using Browser Developer Tools
Use F12 Developer Tools for:

• Network call failures (500/404 status)
• JavaScript runtime errors
• Invalid AJAX responses
• Missing CSS/JS files

Step 9: Use Remote Debugging (Advanced)
Attach Visual Studio debugger to the live IIS process:

• Install Remote Debugging Tools on the server
• From Visual Studio → Debug → Attach to Process

Select w3wp.exe
Great for live issue reproduction.

Step 10: Enable Friendly Error Pages in Production
Use custom error pages to show user-friendly messages.
<customErrors mode="On" defaultRedirect="~/Error">
  <error statusCode="404" redirect="~/Error/NotFound"/>
  <error statusCode="500" redirect="~/Error/ServerError"/>
</customErrors>

Common MVC Error Checklist

Conclusion

Troubleshooting a .NET MVC application becomes much easier when you follow a systematic approach. Always:
✔ Enable logging
✔ Capture error details
✔ Check IIS & permissions
✔ Validate configuration
✔ Test routing and dependencies

With the right techniques, you’ll diagnose and resolve most issues quickly and professionally.

Step 1
Create project

Open Visual Studio -> click File -> New-> Project. 

Visual C#-> Web -> ASP.NET Web Application-> write Project Name-> OK.

Select MVC template. Empty-> Click MVC Folder-> OK.

MVC Folders are created.

Let's understand MVC architecture in ASP.NET
MVC stands for Model, View and Controller. MVC separates an application into three components - Model, View and Controller.

Model
Model represents the shape of the data and business logic. It maintains the data of the Application. Model objects retrieve and store model state in a database.

View
View is a user interface. View displays the data, using model, to the user and also enables them to modify the data.

Controller
Controller handles the user request.

The flow of the user's request in ASP.NET MVC is given below.

First user enters a URL in the Browser (www.google.com)
It goes to the Server and calls an appropriate controller.
The Controller uses the appropriate View and Model, creates the response and sends it back to the user.
Controller handles the user's requests, so first we have to create a Controller

Step 2
Add Controller
Go to the controllers folder-> Add-> Controller-> Select MVC 5 Controller Empty->Add.

It will open Add Controller dialog, as shown below.

Write Controller Name. Do not delete the word Controller. Remember, controller name must end with Controller.

This will create HomeController class with Index method in HomeController.cs file under Controllers folder, as shown below.

Step 3
Add View
Open a HomeController class -> right click inside Index method -> click Add View.

In Add View dialogue box, keep the view name as Index.

This will create View.

Step 4

    Write code in controller class as shown below  
    using System;  
    using System.Collections.Generic;  
    using System.Linq;  
    using System.Web;  
    using System.Web.Mvc;  
    namespace HelloWorldExample.Controllers {  
        public class HomeController: Controller {  
            public ActionResult Index() {  
                ViewBag.message = "Hello World";  
                return View();  
            }  
        }  
    }  

Step 5
    Write code in View as shown below  
    @ {  
        Layout = null;  
    } < !DOCTYPE html > < html > < head > < meta name = "viewport"  
    content = "width=device-width" / > < title > Index < /title> < /head> < body > < div > @ViewBag.message < /div> < /body> < /html>  

Note
Here, I am using ViewBag. It is used to transfer the data from the controller to the view.

Output

This article explains how we can create the Layout (Master) page in MVC 5. Also, it explains the components of Master Page.

Creating Layout Pages

Create a new MVC Project.

Add MVC Layout page in Share folder.
Note: Share folder pages can be used across the project.

Add the below content to the Layout page.

Nav- Nav tags are generally used for navigation bar. We can add links to navigate between the pages.

@RenderSection- Render section is just like a place holder where we can place our code that we can inject from the content page. If we make render section property true, we must need to add this section in all the pages which are used in this layout page, otherwise it will go through as a not implemented error. If we want to make this an option, we need to set it to false.

@RenderBody- RenderBody is a place holder to display the content of the View.

Header & Footer- These are useful to display the header and footer information.

Add Controller and its View to create your page.

Select a new layout page while creating the View.

The below Index View is created by using _RKMaster.cshtml page. In general, if you use _Layout.cshtml, it doesn't display here because it is set in the global default Master page. If we want to set our Layout page as default layout page, we need to set it in _ViewStart.html page, as shown below.

Add the Render section and page content in the View.

Configure your Controller in Route Config to take it as default, and execute the project.

Final View- The header, nav, and footer are coming from the Master Layout page, while the section and page body are rendering from the View page.

Hope this article helps you in understanding the Layout pages and its content.

Anyone interested in learning how to use the Asp.net core MVC application to save data in browser cookies should read this post. You can use the ASP.NET Core MVC web application to develop a sample web application if you wish to put it into practice.

Let's begin.

In essence, a cookie is a tiny bit of information sent to the user's web browser by the server. It might be saved by the browser and sent back to the same server with a subsequent request. Usually, the browser uses it to determine whether two requests originated from the same browser.

Types of cookie 
Persistent cookie
A cookie that has not to have expired time which is called a persistent cookie 

Non-Persistent cookie
Cookie which has expired time is called a Non-persistent cookie 

Adding cookie to the browser
First, add methods inside the Home controller. I have created an action method as CreateCookie and I have added key as DemoCookie. After that I have stored string value as Yogesh so we can store this value in the client browser 
public IActionResult CreateCookie() {
    string key = "DemoCookie:;
    string value = Yogesh;
    cookieOptions obj = new CookieOptions();
    obj.Expires = DateTime.Now.AddDays(7);
    Response.Cookie.Append(key, value, options);
    return view();
}

To see the cookie which is added in the browser I am using Google Chrome.

Now we will see how to retrieve data from cookies, here I have created Action Method ReadData that is used to retrieve data from cookies.
public IActionResult Read Data() {
    string key = "DemoCookie";
    var CookieValue = Request.Cookies[key];
    return View();
}

Now we will see how to delete data that is stored in cookies, here I have created the Action method Delete to perform the Delete operation on the cookie.

public IActionResult Delete() {
    string key = "DemoCookie";
    string value = DateTime.Now.ToString();
    CookieOptions options = new CookieOptions();
    options.Expires = DateTime.Now.AddDays(-1);
    Response.Cookies.Append(key, value, options);
    return View();
}

Summary 
In this article, we have seen how to store data into cookies and retrieve and delete data from cookies. Hope you guys like it. Happy Coding!

Both appear to be comparable at first glance. They enable us to reuse user interface elements on other sites. However, they differ greatly under the hood. The distinctions, applications, performance factors, and when to pick one over the other will all be covered in this article.

What is a Partial View?

• A Partial View is a Razor view (.cshtml) file that can be reused inside other views.
• It is essentially a fragment of HTML + Razor that does not have its own controller logic.

Think of it like a shared template. If you’ve worked with ASP.NET WebForms before, you can compare it to a UserControl (.ascx).
Example

_LoginPartial.cshtml
@if (User.Identity.IsAuthenticated)
{
    <p>Welcome, @User.Identity.Name</p>
    <a href="/Account/Logout">Logout</a>
}
else
{
    <a href="/Account/Login">Login</a>
}

You can include it in your main view as:
@Html.Partial("_LoginPartial")

or asynchronously:

@await Html.PartialAsync("_LoginPartial")
Key Point: A Partial View does not have its own logic. It depends on the data passed from the parent view’s controller.

What is a ViewComponent?
A ViewComponent is like a mini-controller.
It combines C# logic + a Razor view into a self-contained unit.

It allows you to encapsulate business logic and rendering in one place, making it perfect for widgets that require their own data fetching.

Example
ViewComponents/CartSummaryViewComponent.cs
public class CartSummaryViewComponent : ViewComponent
{
    private readonly ICartService _cartService;

    public CartSummaryViewComponent(ICartService cartService)
    {
        _cartService = cartService;
    }

    public IViewComponentResult Invoke()
    {
        var cart = _cartService.GetCart(User.Identity.Name);
        return View(cart);
    }
}

The Razor view (Views/Shared/Components/CartSummary/Default.cshtml):
<div class="cart-summary">
    <p>Items in cart: @Model.Items.Count</p>
    <p>Total: @Model.TotalPrice.ToString("C")</p>
</div>

Usage in your main view:
@await Component.InvokeAsync("CartSummary")

Key Point: A ViewComponent has its own logic and data source. It does not rely on the parent controller’s model.

Key Differences Between Partial View and ViewComponent

When to Use Partial View?

Use a Partial View when:

• You only need reusable HTML markup.
• Data comes from the parent controller.
• Example scenarios:
• Website header and footer
• Navigation menus
• Shared static templates like the Terms & Conditions section

Code Example

@Html.Partial("_Header")
@Html.Partial("_Footer")

When to Use ViewComponent?
Use a ViewComponent when:

• You need business logic + view rendering together.
• Data comes from a different source than the parent view.
• You want testability (since ViewComponents can be unit tested).
• Example scenarios:
  • Shopping cart summary
  • Latest blog posts widget
  • Notification panel
  • User profile box

Code Example
@await Component.InvokeAsync("LatestPosts", new { count = 5 })

Performance Considerations

• Partial View is faster for simple static rendering because it does not invoke additional logic.
• ViewComponent is slightly heavier, but it provides better separation of concerns and testability.
• In real-world projects, mixing both approaches works best.

Conclusion
ASP.NET MVC/Core offers two strong tools for creating modular, maintainable applications: Partial Views and ViewComponents.

• For basic, static UI fragments, use partial views.
• For reusable, logic-driven user interface elements, use ViewComponents.

You may improve the scalability, maintainability, and cleanliness of your application by selecting the appropriate strategy for each situation.