Design An Interactive Windows Application In C# For Applying ✓ Solved

Design an interactive Windows application in C# for applying

Design an interactive Windows application in C# for applying filters on an image.

Specific Requirements:

- Your application should take picture from camera or upload from the computer.

- Once you select any filter from the filter menu it will apply your selected filter on the picture.

- Zoom menu will allow the user to maximize the picture when Hover.

- Detail menu allow the user to show the detail of the system.

- GUI is not restricted; you can create your customized GUI.

Question 2:

Write a program named Super Market Product Management System that asks a user to enter ProductID, product name, date of entrance, product sold and product available. The system must provide functionality to add data, update data, delete data, and search and display data. The program must include object-oriented concepts: classes, inheritance, polymorphism, composition where required, and operator overloading where required. For storage, either use SQL Server database backend or use file-based storage. The program must handle runtime exceptions and present a proper Main Menu.

Paper For Above Instructions

Overview

This document describes a practical design and implementation plan for two C# projects specified above: (1) an interactive Windows image‑filtering application and (2) a Super Market Product Management System. The aim is to map requirements to architecture, user interface behavior, class structure, data storage options, and implementation notes for robustness and usability.

1. Image Filtering Windows Application — High-level Design

Core features: capture from camera or upload from disk, apply selectable filters, zoom-on-hover, a Details menu showing system/app information, and a customizable GUI. The application can be implemented using WinForms or WPF; WPF is recommended for richer UI and smooth transform animations (zoom on hover) [6]. For image processing, use a managed library such as AForge.NET or Emgu CV (OpenCV wrapper) for robust, optimized filters, or implement lightweight filters using convolution kernels via System.Drawing.Bitmap for learning purposes [2][3][4].

Filter Implementation

Provide a filter menu with standard filters: Grayscale, Sepia, Invert, Gaussian Blur, Sharpen, Edge Detection (Sobel). Filters are implemented as pixel operations or convolution kernels (kernels and separable convolutions based on Gonzalez & Woods) [1]. For performance, apply filters using unsafe pointers or LockBits for direct pixel buffer access in System.Drawing, or delegate heavy processing to native OpenCV through Emgu CV for real-time camera feed processing [3][4].

Camera and Upload

Camera capture uses Windows multimedia APIs or MediaCapture (UWP) or DirectShow wrappers; Emgu CV/AForge can enumerate cameras and provide frames as bitmaps [2][5]. Provide two UI flows: Upload (OpenFileDialog -> load Bitmap) and Camera (Start/Stop stream, snapshot button -> freeze frame to apply filters).

Zoom on Hover & Details Menu

Zoom-on-hover is achieved with mouse events and a ScaleTransform in WPF or a PictureBox overlay in WinForms. On MouseEnter, animate a scale to, for example, 1.5x; on MouseLeave animate back to 1x. The Details menu should gather Environment and application metadata (OS, .NET runtime, camera status, image resolution) and show it in a dialog [6].

UX & Accessibility

Design a clear toolbar for filters with icons and labels. Allow preview and apply semantics (Preview applies a non-destructive overlay; Apply commits to the working bitmap). Provide keyboard shortcuts and accessible labels to improve SEO and usability.

2. Super Market Product Management System — Design

Functional requirements: accept ProductID, name, date of entry, sold, available; support Add, Update, Delete, Search, and Display. The design demonstrates OOP concepts: classes, inheritance, polymorphism, composition, and operator overloading where appropriate.

Core Class Design

Define a Product base class with properties: ProductID, Name, DateEntered, SoldQuantity, AvailableQuantity, and methods: ToString(), Validate(). To show inheritance and polymorphism, derive classes such as PerishableProduct (adds ExpiryDate) and ElectronicProduct (adds WarrantyPeriod). Override methods like GetDisplayLabel() to demonstrate polymorphism [8].

Composition and Aggregation

Implement an Inventory class that composes a collection (List<Product>) and exposes methods AddProduct, UpdateProduct, DeleteProduct, FindProduct (by ID or name), and GetAllProducts. The Inventory handles persistence coordination and business rules (e.g., available = initial - sold).

Operator Overloading

Demonstrate operator overloading in Product, for example overload + to merge stock of two Product instances with the same ProductID returning a new Product whose AvailableQuantity is the sum, and overload ==/!= to compare by ProductID. Use operator overloading sparingly and document the semantics for maintainability (C# supports operator overloading) [7].

Persistence Options

Option A — SQL Server backend: use ADO.NET or Entity Framework Core to map Product/Inventory classes to database tables. Use parameterized queries or EF migrations, transactions for multi-row updates, and connection pooling for performance [7]. Option B — File-based storage: use JSON or XML serialization for simple deployments (System.Text.Json or Newtonsoft.Json). Persist a single Inventory JSON file; implement file locking and atomic write (write temp file then replace) to reduce corruption risk.

Exception Handling & Validation

Validate user inputs (IDs unique, numeric quantities non-negative, date format) on the UI and in the model. Handle runtime exceptions (IOExceptions, SqlException, FormatException) with try-catch blocks and present user-friendly error messages while logging stack traces to a log file. Follow recommended exception handling best practices to avoid swallowing exceptions [9].

Main Menu & UX

Provide a clean Main Menu with entries: Inventory > Add Product, Update Product, Delete Product, Search Product, Display All, Settings (DB/file selection), and Help & About. Use modal dialogs for CRUD operations and a data grid to show search/display results with sorting and filtering.

Implementation & Testing Notes

Prototyping: start with a Minimum Viable Product (MVP): image upload + a single filter and Inventory CRUD with file-based persistence. Gradually add camera integration, additional filters, SQL persistence, and refined UI. Use unit tests for Inventory logic and integration tests for persistence. Profile image processing to identify bottlenecks; use native libraries (OpenCV/Emgu) for high throughput [3][4].

Security and Deployment

Secure database connections with integrated authentication or securely stored connection strings. For file storage, restrict directory permissions. Package the Windows app with an installer (MSIX or MSI) and include runtime prerequisites or publish as a self-contained .NET application for simpler deployment [6][7].

Conclusion

The described approaches satisfy the assignment requirements: the image app supports camera/upload, selectable filters, zoom-on-hover, and a Details menu; the supermarket system demonstrates OOP principles, supports CRUD operations, offers SQL or file storage, and includes robust exception handling and a Main Menu. Using established libraries (AForge/Emgu, EF Core) accelerates development and improves reliability while implementing custom logic provides learning value and flexibility [1][2][3][7].

References

  1. R. C. Gonzalez and R. E. Woods, Digital Image Processing, 4th ed., Pearson, 2018. [1]
  2. AForge.NET Framework — A computer vision and artificial intelligence library. https://www.aforgenet.com/ [2]
  3. Emgu CV — .NET wrapper for OpenCV. https://www.emgu.com/ [3]
  4. Microsoft Docs, System.Drawing.Common Namespace. https://docs.microsoft.com/dotnet/api/system.drawing [4]
  5. Microsoft Docs, Capture video from a camera using MediaCapture. https://docs.microsoft.com/windows/uwp/audio-video-camera/capture-photo [5]
  6. Mark J. Price, C# 8.0 and .NET Core 3.0 – Modern Cross-Platform Development, Packt, 2019. [6]
  7. Microsoft Docs, ADO.NET Overview and SqlClient. https://docs.microsoft.com/dotnet/framework/data/adonet/ [7]
  8. E. Gamma, R. Helm, R. Johnson, and J. Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994. [8]
  9. Microsoft Docs, Exceptions in C# Programming Guide. https://docs.microsoft.com/dotnet/csharp/programming-guide/exceptions/ [9]
  10. R. C. Martin, Clean Architecture: A Craftsman's Guide to Software Structure and Design, Prentice Hall, 2017. [10]

Related Assignments