Exploring ASP.NET MVC

I often find myself trying out new approaches and methods to tackle different challenges. That's where the SampleMvcCRUD project comes in. It has become something of a "Swiss army knife" for me to test out different approaches and to experiment with upgrades to the latest versions of both the .Net Core version and NuGet package versions.

As we know, CRUD operations form the backbone of many applications, and it's essential to have a solid understanding of how to implement them. The SampleMvcCRUD project provides multiple ways of implementing these operations using different approaches in Microsoft .Net.

I wanted to share my experience with a GitHub project to demonstrate ASP.Net MVC applications with CRUD – create, read, update, and delete operations. This is a tour of the project, explaining everything from the different approaches used to implement CRUD operations to the various deployment options available.

The SampleMvcCRUD project includes a model called Employee that includes Department to show lookup techniques. The model supports an image that can be set for each Employee, and the images are stored on the file system of the application. Additionally, the code generates MOCK sample data so that every time you run the application, you get a different set of data.

Data Model Interfaces

public interface IEmployee
{
  int Age { get; set; }
  string? Country { get; set; }
  Department Department { get; set; }
  int DepartmentId { get; set; }
  int? ManagerId { get; set; }
  string Name { get; set; }
  string? ProfilePicture { get; set; }
  string? State { get; set; }
}
public interface IDepartment
{
  string Description { get; set; }
  ICollection>Employee< Employees { get; set; }
  string Name { get; set; }
}

In SampleMvcCRUD, I used the in-memory SQLite database and Bogus to generate fresh test data on every execution of the application. This approach ensures that the application is tested with a different set of data each time it is run, making it easier to identify any potential issues that may arise. By using Bogus, I was able to create realistic-looking data, including names, ages, states, and departments, to simulate a real-world scenario. h5.mb-3.text-success Data Generation with Bogus

public static List<Employee> GetEmployeeList(int generateCount)
{
  var states = new string[] { "Alabama", "Alaska", "Arizona",  };
  var fakeEmployees = new Faker<Employee>()
    // Call for objects that have complex initialization
    .CustomInstantiator(f => new Employee())
      .RuleFor(u => u.Name, (f, u) => f.Name.FullName())
      .RuleFor(u => u.Age, f => f.Random.Number(18, 70))
      .RuleFor(u => u.DepartmentId, f => f.Random.Number(1, 6))
      .RuleFor(u => u.Country, "USA")
      .RuleFor(u => u.State, f => f.Random.ListItem(states))
      .FinishWith((f, u) => { });
  return fakeEmployees.Generate(generateCount);
}

Overall, the Bogus library is a great tool to have in your toolbox as a .NET developer. It can help you generate sample data for testing purposes and ensure that your application is functioning correctly. For more information, check out a.text-decoration-none(href='https://github.com/bchavez/Bogus', target='_blank', rel='noopener noreferrer') the Bogus library on GitHub | .

User interface (UI) is the point of interaction between a user and a software application. It includes all the visual and interactive elements of the application that users see and use to interact with the system. In the context of SampleMvcCRUD, the UI is the part of the application that allows users to create, read, update, and delete data from the system.

The choice of the UI implementation approach depends on the specific requirements of the application. If the application requires high interactivity and real-time updates, then the SPA approach may be the best option. If the application requires a clear separation between the presentation layer and the business logic, then the server-side MVC approach may be more appropriate. If the application needs to combine the benefits of both approaches, then the AJAX-based MVC approach may be the best option.

Deploying an application is just as important as developing it, and the SampleMvcCRUD project demonstrates several deployment options. When it comes to deploying an application, there are many cloud computing options available. For this application, I chose to demonstrate 2 of these options as they are the most common.

Current Deployment Environments

Continuous Integration & Deployment (CI/CD)

One of the key concepts of DevOps is Continuous Integration and Continuous Deployment (CI/CD), which involves automating the process of building, testing, and deploying software. This helps to ensure that any new code changes are thoroughly tested and deployed quickly and efficiently.

GitHub Actions enables developers to create automated workflows, triggered by events such as a pull request, that can build, test, and deploy their code automatically. These workflows can include gates that check that any new code compiles and passes automated tests before it is merged into the main branch of the repository.

Application Containerization

Containerization is another important aspect of DevOps that involves packaging an application into a container that can be deployed consistently across different environments. Docker is a popular containerization platform that allows developers to build, test, and deploy their applications in a standardized way.

Containerization is a powerful tool for modern application development and deployment, allowing developers to easily package and deploy applications across multiple environments with consistency and reliability. While there are some potential drawbacks to containerization, these can generally be mitigated with careful planning and management and the benefits of containerization make it well worth considering for any modern application deployment.

The SampleMvcCRUD project has become something of a "Swiss Army knife" for me, allowing me to test out new approaches and methods, as well as upgrades to the latest versions of both .NET Core and NuGet packages.

In this project, I have explored multiple ways to implement CRUD operations using different approaches in Microsoft .NET frameworks. I have also discussed the use of containerization, continuous integration and deployment (CI/CD), and other modern development practices.

So if you're a fellow lifelong learner, I invite you to follow the SampleMvcCRUD project and see what new updates and techniques have been added. And if you have any suggestions or ideas for new sections or features, feel free to let me know – because as developers, we're always learning.