📋 MonitorDetailViewModel.cs Documentation

Assembly: IrbyImaging.UI
Namespace: IrbyImaging.Models
Author: kvamshi
Created: 03‑31‑2022
Last Modified: 03‑31‑2022


Table of Contents

  1. Overview & Purpose 📖
  2. Dependencies & Technologies 🔗
  3. View‐Model Hierarchy & UML 📊
  4. MonitorDetailViewModel Implementation ⚙️
  5. How to Use / Sample Code Snippets 💻
  6. Error Handling & Return Types 🚨
  7. Third‑Party Integrations 🔌
  8. Conclusion & Best Practices ✅

1. Overview & Purpose 📖

MonitorDetailViewModel is a ViewModel designed to carry the details of a Monitor entity from the server‑side to a UI (e.g., an ASP.NET MVC or Razor Pages view).
It derives from a generic DetailViewModel base class which encapsulates common properties and behaviors (such as Id, CreatedDate, ModifiedDate, etc.).

Key Goals

  • Provide a strongly‑typed container for monitor‑specific data in the UI layer.
  • Leverage shared behavior from DetailViewModel (validation, common metadata, audit fields).
  • Facilitate mapping (via AutoMapper or manual mapping) from domain models to UI models.

2. Dependencies & Technologies 🔗

Technology Version / Details
.NET / .NET Core 5.x or later
C# Language 8.0+
ASP.NET MVC / Razor For rendering the view
AutoMapper (opt.) For object‑to‑object mapping
DetailViewModel Abstract base in IrbyImaging.Models

Note: The base DetailViewModel is defined elsewhere in the IrbyImaging.Models namespace and provides shared properties like Id, Title, and auditing fields.


3. View‐Model Hierarchy & UML 📊

@startuml
abstract class DetailViewModel {
    + int Id
    + string Title
    + DateTime CreatedOn
    + DateTime? ModifiedOn
    + bool IsActive
    + void Validate()
}

class MonitorDetailViewModel {
    -- inherits DetailViewModel --
}

DetailViewModel <|-- MonitorDetailViewModel
@enduml
  • DetailViewModel (Base)
    • Contains common detail‑oriented properties & methods.
  • MonitorDetailViewModel (Derived)
    • Specialized for Monitor entities; inherits all members with no further extension (for now).

4. MonitorDetailViewModel Implementation ⚙️

// ***********************************************************************
// Assembly    : IrbyImaging.UI
// Author      : kvamshi
// Created     : 03-31-2022
// Last Modified By : kvamshi
// Last Modified On : 03-31-2022
// ***********************************************************************
// <copyright file="MonitorDetailViewModel.cs" company="IrbyImaging.UI">
//     Copyright (c) . All rights reserved.
// </copyright>
// <summary>ViewModel for displaying detailed Monitor information.</summary>
// ***********************************************************************
using IrbyImaging.Models;

/// <summary>
/// Class MonitorDetailViewModel.
/// Implements the <see cref="DetailViewModel" />.
/// </summary>
/// <seealso cref="DetailViewModel" />
public class MonitorDetailViewModel : DetailViewModel
{
    // Currently inherits everything from DetailViewModel.
    // Add Monitor‑specific properties here, for example:
    // public string Resolution { get; set; }
    // public decimal SizeInInches { get; set; }
}

Explanation of Key Pieces

  • public class MonitorDetailViewModel : DetailViewModel
    Inherits all common detail view‑model logic.
  • No additional members have been defined here, but the class is open for extension with monitor‑specific fields (e.g., Resolution, ScreenType, Manufacturer).

5. How to Use / Sample Code Snippets 💻

5.1 Controller Usage

using Microsoft.AspNetCore.Mvc;
using IrbyImaging.Models;
using AutoMapper;

public class MonitorController : Controller
{
    private readonly IMonitorService _monitorService;
    private readonly IMapper _mapper;

    public MonitorController(IMonitorService monitorService, IMapper mapper)
    {
        _monitorService = monitorService;
        _mapper = mapper;
    }

    public IActionResult Details(int id)
    {
        // 1) Fetch domain model from service / repository
        var domainMonitor = _monitorService.GetById(id);
        if (domainMonitor == null)
            return NotFound();

        // 2) Map to ViewModel
        var viewModel = _mapper.Map<MonitorDetailViewModel>(domainMonitor);

        // 3) Return View
        return View(viewModel);
    }
}

5.2 Razor View Example

@model MonitorDetailViewModel

<h1>Monitor Details 👁️‍🗨️</h1>

<table>
    <tr><th>ID</th>          <td>@Model.Id</td></tr>
    <tr><th>Title</th>       <td>@Model.Title</td></tr>
    <tr><th>Created On</th>  <td>@Model.CreatedOn.ToString("g")</td></tr>
    <tr><th>Last Modified</th><td>@Model.ModifiedOn?.ToString("g")</td></tr>
    <tr><th>Active?</th>     <td>@(Model.IsActive ? "Yes" : "No")</td></tr>
    <!-- Add more rows for Monitor-specific properties -->
</table>

6. Error Handling & Return Types 🚨

  • Null Checks: Ensure domain object exists before mapping; return NotFound() or BadRequest().
  • Model Validation: If you extend MonitorDetailViewModel with data‑annotations (e.g., [Required]), the MVC pipeline will auto‑validate and return 400 on error.
  • Exception Handling: Wrap service calls in try/catch and return StatusCode(500) or a custom error view as needed.

7. Third‑Party Integrations 🔌

  • AutoMapper
    • Profile Configuration:
      public class MonitorProfile : Profile
      {
          public MonitorProfile()
          {
              CreateMap<MonitorDomainModel, MonitorDetailViewModel>();
              // For Edit / Create: CreateMap<MonitorDetailViewModel, MonitorDomainModel>();
          }
      }
      
  • FluentValidation (optional)
    • You can create a MonitorDetailViewModelValidator : AbstractValidator<MonitorDetailViewModel> to enforce business rules on the view model.

8. Conclusion & Best Practices ✅

  • Single Responsibility: MonitorDetailViewModel exists solely to carry monitor details to the view.
  • Open for Extension: As your UI needs grow, simply add new properties to this class (e.g., ScreenType, Manufacturer, RefreshRate).
  • DRY: Common detail properties and validation logic are centralized in DetailViewModel, preventing duplication across multiple detail view models.
  • Maintainability: By using a dedicated view model, you decouple your domain models from presentation concerns and improve testability.

🎉 Happy Coding! 🎉

End of MonitorDetailViewModel.cs documentation.