Tasks and Duties
Objective: Develop a simple inventory management console application using C#. This task is designed to introduce you to project planning, basic programming logic, and user interaction via a console interface. You will plan your project, design the application structure, and implement core functionalities such as adding, viewing, updating, and deleting inventory items.
Expected Deliverables: A single compressed file containing the complete Visual Studio project folder along with a design document (in PDF or Word format) that outlines the project architecture, UML class diagrams, and a brief explanation of your design choices.
Key Steps to Complete the Task:
1. Analyze the requirements and create a clear project plan.
2. Draw and document a class diagram that represents the key components (e.g., Item, InventoryManager, etc.).
3. Setup a Visual Studio solution with a C# Console Application project.
4. Implement CRUD (Create, Read, Update, Delete) operations for your inventory items with proper error handling.
5. Write inline code comments and include documentation where needed.
6. Test the application to ensure all functionalities work as expected.
Evaluation Criteria: You will be assessed on the clarity of your design document, adherence to C# coding conventions, proper use of object-oriented programming principles, and the functionality of your console application. The task should take approximately 30 to 35 hours to complete, demonstrating your ability to manage a basic project from planning to implementation.
Objective: Build a Windows Forms application to create a fully functional calculator using C#. This task is intended to help you understand GUI development, event-driven programming, and user interaction design. You will create a user interface that allows users to perform simple arithmetic operations (addition, subtraction, multiplication, division).
Expected Deliverables: A complete C# Visual Studio project folder containing the Windows Forms application source code. Additionally, include a brief design report (in PDF or Word format) explaining your UI design choices, event handling logic, and any challenges encountered.
Key Steps to Complete the Task:
1. Design a user-friendly UI layout with buttons for digits, arithmetic operators, and a display area.
2. Create the Windows Forms application and implement UI components using Visual Studio drag-and-drop tools.
3. Code the functionality for each button to handle arithmetic operations and clear/reset functionalities.
4. Test the application thoroughly to handle edge cases such as division by zero and invalid inputs.
5. Document your code with comments, and explain the logic behind your event handler implementations in your design report.
Evaluation Criteria: You will be assessed on the functionality and robustness of the calculator, the usability of the user interface, adherence to best practices in C# Windows Forms development, and the clarity of your design report. The entire task is expected to take around 30 to 35 hours, requiring substantial practical work and attention to detail.
Objective: Enhance and refactor an existing C# application by applying principles of clean code and integrating unit testing. This task will expose you to the importance of maintaining code quality, modularity, and the testing framework. You will refactor parts of your Week 1 or Week 2 project, improve its code structure, and write unit tests using a testing framework such as NUnit or MSTest.
Expected Deliverables: A revised Visual Studio project folder containing your refactored source code along with a suite of unit tests. Additionally, submit a document (in PDF or Word format) that describes the refactoring decisions, a summary of your testing strategy, and the expected outcomes of your tests.
Key Steps to Complete the Task:
1. Review and identify areas in your existing project where the code can be refined for readability and maintainability.
2. Apply refactoring techniques, such as extracting methods, reducing code duplication, and enhancing module separation.
3. Integrate a unit testing framework (e.g., NUnit, MSTest) into your project and write comprehensive tests for critical functionalities.
4. Ensure your tests cover normal cases, edge cases, and error handling scenarios.
5. Create documentation that outlines your refactoring choices and explains how your unit tests validate the improved functionalities.
Evaluation Criteria: Your submission will be evaluated on the logical structure and clarity of your refactored code, the effectiveness and coverage of your unit tests, and the comprehensiveness of your documentation. The task is expected to take approximately 30 to 35 hours, emphasizing the integration of development best practices and practical testing methodologies.
Objective: Develop a small C# project that demonstrates the integration of a database using Entity Framework Core. This task focuses on creating a CRUD application that interacts with a SQLite database. You will implement data models, context classes, and perform database operations to build a robust data-driven application.
Expected Deliverables: A complete Visual Studio project folder that includes the source code for your C# application using Entity Framework Core. The project should include a README file explaining how to set up, configure, and run the application, as well as descriptions of the data models and database interactions.
Key Steps to Complete the Task:
1. Design a simple domain model for a CRUD application (for example, a student information system or product catalog).
2. Create a Visual Studio solution and set up the necessary Entity Framework Core NuGet packages.
3. Define your data models and DbContext class to interact with a SQLite database.
4. Implement functionalities to add, update, delete, and view records in the database.
5. Ensure that you handle exceptions and edge cases, such as database connection issues and invalid data formats.
6. Document your project with inline comments and a README file detailing setup instructions and an overview of your implementation.
Evaluation Criteria: The task will be assessed based on the correctness of database operations, the clarity of your code and documentation, and the effective use of Entity Framework Core for data access. The approximate effort for this task is 30 to 35 hours, ensuring you gain hands-on experience with data-driven application development in C#.
Objective: Consolidate your learning by enhancing an existing C# project with improvements based on feedback, personal review, and best coding practices. This final task requires you to integrate features from your previous weeks’ work, perform a comprehensive code review, incorporate advanced functionalities, and optimize your project for maintainability and performance. The emphasis is on applying best practices, documenting your code, and ensuring the application is production-ready.
Expected Deliverables: A complete, final Visual Studio project folder that includes all source code improvements and additional functionalities. Additionally, submit a detailed code review report (in PDF or Word format) that outlines the changes you made, the rationale behind these improvements, and the testing strategies you implemented to ensure the application meets quality standards.
Key Steps to Complete the Task:
1. Choose an existing project from previous tasks (either the console application, Windows Forms application, or the Entity Framework project) and plan enhancements and new feature integrations.
2. Conduct a thorough code review focusing on areas such as code structure, naming conventions, performance, and security vulnerabilities.
3. Refactor your code to incorporate best practices and remove any anti-patterns.
4. Implement additional functionalities or optimizations based on your review, such as improved error handling, additional features, or enhanced user experience.
5. Write or update unit tests to cover new functionalities and ensure robustness.
6. Document your revision process and justify your design decisions in a comprehensive code review report.
Evaluation Criteria: Submissions will be evaluated on the quality and clarity of your code, the depth of your code review report, the effectiveness of your improvements, and the overall performance and maintainability of the project. This final task is designed to require approximately 30 to 35 hours of dedicated work and serves as an opportunity to demonstrate your readiness for more advanced development challenges.