Architecture

When designing a Windows Forms application, you have several architectural patterns to choose from. The common ones are:

Model-View-Controller (MVC):

  • Description: MVC separates the application into three components:
    • Model: Represents the data and business logic.
    • View: Handles the presentation and user interface.
    • Controller: Manages user input and communicates between the Model and View.
  • Pros:
    • Clear separation of concerns.
    • Reusable components.
    • Supports unit testing.
  • Cons:
    • Can become complex for small applications.
    • Requires careful design to avoid tight coupling.
  • Use Case: Suitable for medium to large applications with complex interactions.

Clean Architecture:

  • Description: Clean Architecture emphasizes separation of concerns and independence from external frameworks.
  • Entities: Represent core business logic.
  • Use Cases (Interactors): Application-specific business rules.
  • Interfaces (Gateways): Define external interfaces (e.g., database, UI).
    • Frameworks & Drivers: External frameworks and tools (e.g., Windows Forms, databases).
    • Pros:
      • Highly modular and testable.
      • Adaptable to changes in external frameworks.
      • Focuses on business logic.
    • Cons:
      • Initial setup complexity.
      • May be overkill for small projects.
    • Use Case: Suitable for large, long-lived applications with evolving requirements.

Subsections of Architecture

Migrations

In .NET 8, when a migration attempts to create a table that already exists in the database, the behavior depends on the state of the migration history and the existing database schema:

Initial Migration

When you apply the initial migration, Entity Framework Core (EF Core) creates the specified tables based on your model. If the table already exists in the database, EF Core will not re-create it. It only creates tables that are not present.

Subsequent Migrations

For subsequent migrations (e.g., adding columns, modifying schema), EF Core generates migration scripts based on the difference between the current model and the previous migration’s snapshot. If a table is already in the database and corresponds to the model, EF Core will not attempt to create it again. However, if the table structure differs from the model (e.g., missing columns), EF Core will generate migration scripts to update the schema.

Migration History

EF Core maintains a special table called __EFMigrationsHistory (or __migrations_History in some databases). This table tracks which migrations have been applied to the database. If a migration has already been applied (recorded in this table), EF Core will skip creating the corresponding tables.

Rollback (Down) Method

The Down method in a migration handles rolling back changes. If you need to undo a migration, the Down method drops the corresponding tables. For example, if you remove a column in a migration, the Down method will drop that column.

Manual Truncation or Deletion

Be cautious when manually truncating or deleting tables (including the __EFMigrationsHistory table). If the migration history is lost, EF Core may treat subsequent migrations as initial migrations, leading to re-creation of existing tables. In summary, EF Core is designed to be aware of the existing database schema and avoid unnecessary table creation. Ensure that the migration history is intact, and avoid manual truncation of the migration history table to prevent unexpected behavior during migrations

Synchronize

AMPLI-SYNC is a framework for synchronizing data between a SQLite database and an MS SQL/MySQL/Oracle/PostgreSQL database.

It allows your application to work offline (Airplane Mode) and then perform automated bidirectional synchronization when an internet connection becomes available.

Official site