DEV Community: Clover Luo

Building a User Registration System in .NET Core & C#

Clover Luo — Sat, 15 Feb 2025 14:33:59 +0000

🚀 My journey into ASP.NET Core: Implementing a User Registration System 🚀

Hey Devs! 👋 I'm learning .NET Core and C# and recently built a user registration system for my web application. I wanted to share my experience and how I implemented the Register method using ASP.NET Core Identity and Entity Framework.

🔧 Technologies Used

ASP.NET Core MVC for building the web application
Entity Framework Core for database management
SQL Server for user authentication storage
ASP.NET Identity for managing users securely

📌 Implementing the Register Method

Step 1: Create the RegisterViewModel
First, I created a view model to handle user registration inputs.
This ensures validation rules like required fields, email format, and password matching.

Step 2: Register Method in AccountController
Now, let's implement the registration logic inside AccountController.cs.

Validates the user input
Creates a new user in the database using UserManager
Redirects to the login page upon successful registration

Step 3: Register View in Register.cshtml
The frontend part is a simple HTML form in Register.cshtml that posts data to the Register method.

Uses Razor syntax to bind form inputs to RegisterViewModel
Implements validation messages via asp-validation-for
Submits form data to the Register method in AccountController.cs

💡 What I Learned

✅ How to validate user input in ASP.NET Core
✅ How to register users using UserManager<>
✅ How to secure passwords with ASP.NET Identity
✅ How to connect the frontend with backend logic

🌍 Full Source Code

You can find the full source code in my GitHub repo:
🔗 https://github.com/cloverluo112/WebApplication1

🚀 Next Steps
In my next post, I'll cover login authentication and securing user sessions with JWT tokens! Stay tuned! 😃

Let me know in the comments if you have any questions or improvements! 🙌

Learning DTOs, Controllers, and Services in C# .NET: My Journey with the task app 🚀

Clover Luo — Tue, 08 Oct 2024 12:50:32 +0000

Hey Dev Community! 👋

As part of my role in the project introduced before, I recently completed an exciting task that pushed me to dive deeper into C# .NET development. This task involved creating a new DTO (Data Transfer Object), writing a controller, and implementing a service layer to return all label data using an HTTP GET endpoint. It was a great learning experience, and I’d love to share what I learned!

The Task Breakdown

The task I worked on involved the following steps:

Create a new endpoint that returns all label data with the correct structure.
Implement a service layer to handle the query logic. At this stage, mock data was used if the previous work on labels wasn't finished yet.
Test the endpoint using Swagger to ensure everything was working as expected.

What I Learned: The Power of DTOs, Controllers, and Services

DTO (Data Transfer Object): One of the first things I did was create a DTO that matched the structure of the Label entity. The DTO is used to ensure that only the necessary data is passed between layers of the application. This step helped me understand how to keep the application’s internal data structure clean and optimized for performance.
Controller: Next, I wrote a new controller that would handle HTTP requests. The controller is responsible for routing the request to the correct service method. I learned how to define GET endpoints and handle responses in a standardized way.
Service Layer: The service layer is where the actual business logic lives. In this case, I implemented a service that queries the database for all labels, but during development, I used mock data to test the logic. This approach allowed me to build and test independently of the database.

Testing with Swagger

Once everything was set up, I tested the new endpoint using Swagger, which provided an easy way to visualize and interact with the API. It was a great tool to check if my controller and service layer were correctly implemented. After running the API locally, I could see the expected label data being returned successfully!

Key Takeaways

DTOs are crucial for keeping data clean and secure when it travels between layers of an application.
Controllers help manage routing and make sure HTTP requests are directed to the right place.
Service layers encapsulate business logic, making the application modular and easy to maintain.
Testing with Swagger is an easy and efficient way to validate endpoints and ensure that the API behaves as expected.

Conclusion

This task was a great learning experience, and I’m excited to continue building more features for the project. Writing DTOs, controllers, and service layers has given me a much better understanding of how a full-stack application works, and I’m looking forward to applying these skills in future projects.

I’ll continue documenting my learning journey, so stay tuned for more updates!

My First Day Writing C# Code: Implementing Labels in Blotz Task App 🎉

Clover Luo — Fri, 04 Oct 2024 15:13:56 +0000

Hey Dev Community! 👋

Today I want to take a moment to reflect on the first day I wrote C# code and implemented my very first PBI (Product Backlog Item) for the Blotz Task App. The task was to create a label entity, which would allow tasks to be categorized, similar to how platforms like Todoist handle tags. This was a great introduction to backend development in C#, and I learned a lot from the process!

What I Implemented

Here’s a summary of what I worked on:

Label Entity: I created a Label class that will store labels for categorizing tasks. This involved setting up properties like Name, Color, and Description for each label.
Database Integration: After setting up the label entity, I integrated the class into the DbContext by adding some mock data. This allowed me to work with sample labels in the system.
Data Migration: I also ran my first data migration to ensure that the label table and its properties were correctly reflected in the database. Learning how to run migrations and manage schema updates was a big step in my backend learning journey.

What I Learned

Through this experience, I learned some valuable backend development skills:

Entity Framework Core: I got hands-on experience with Entity Framework Core, understanding how entities are mapped to database tables and how relationships are defined.
Data Migrations: I learned how to run data migrations and update the database schema with new entities. This was crucial for ensuring my changes were properly applied in the database.
Mock Data: Adding mock data to the DbContext was a fun way to see how my label entity would behave in the application. This helped me visualize how the app would categorize tasks using labels.

Overall, this experience gave me a deeper understanding of how backend systems work and how data is handled behind the scenes. I'm excited to continue learning and growing as I take on more backend tasks in this project!

Stay tuned for more updates as I continue to document my learning journey!

Journey into Backend Development with the Blotz Task App 🚀

Clover Luo — Thu, 03 Oct 2024 16:51:05 +0000

Hey Dev Community! 👋

I’m excited to share the start of my journey into backend development and SQL through a new project I’ve recently kicked off called Blotz Task App. This group project is an awesome opportunity for me to dive deeper into full-stack development, and I’m taking the lead on backend development and database management. You can check out the project here on GitHub.

Why the Blotz Task App?

I’ve always been passionate about learning all aspects of web development, and while I’ve spent a good amount of time working on frontend projects (JavaScript, React, etc.), I wanted to expand my horizons by getting more hands-on with the backend and working closely with SQL databases. Blotz Task App is a task management tool that aims to help users efficiently organize and track their tasks. For me, this project is more than just a tool—it’s a learning experience.

My Role: Backend & Database

As the one leading the backend, I’m responsible for ensuring that the data flows smoothly between the frontend and the database. I’ve been diving into C# and .NET Core, which has been an exciting challenge so far. I’m also getting my hands dirty with SQL Server, learning to design and optimize a scalable database schema that can handle user-generated tasks and interactions efficiently.

I’ve always believed that backend development is like the backbone of any great application—without a solid foundation, the entire app can fall apart. My goal for this project is to make sure we have a backend that is robust, scalable, and reliable.

What I’ve Learned So Far

In just the short time I’ve been working on this project, I’ve already picked up a ton of new knowledge about backend systems and database management. Here are a few key takeaways:

Understanding RESTful APIs: I’m building REST APIs to ensure smooth communication between the frontend and the database, which has given me a clearer understanding of how different parts of an app connect.
SQL Query Optimization: I’ve started learning how to optimize SQL queries for better performance, especially when working with large datasets. I’m finding this part really fascinating because it directly impacts the app’s speed and responsiveness.
C# and .NET Core: I’m still deepening my understanding of C# and .NET Core, which have proven to be powerful tools for backend development. The learning curve has been steep, but that’s what makes it so rewarding!

Next Steps & Learning Goals

This is just the beginning! As I continue working on this project, I plan to:

Explore Entity Framework Core for database migrations and optimizations.
Experiment with Azure SQL Database for deploying a cloud-based solution.
Keep refining my backend architecture for maximum efficiency and scalability.

Full-Stack Development Passion

Although I’m focusing on backend and databases for now, I’m deeply passionate about full-stack development. Understanding how every part of an application works—both frontend and backend—is what drives me. I believe that being well-versed in both areas will allow me to build more complete and cohesive applications in the future.

I’ll continue to document my learning process and challenges in this project. If you’re interested in following along or contributing, feel free to check out our repository here. Stay tuned for more updates!

Happy coding! ✌️