ASSIGNMENT 2 FRONT SHEET

Qualification BTEC Level 5 HND Diploma in Computing

Unit number and title Unit 1: Programming

Submission date Date Received 1st submission

Re-submission Date Date Received 2nd submission

Student Name Tran Van Toan Student ID BH00485

Class SE06201 Assessor name Dinh Van Dong

Student declaration
I certify that the assignment submission is entirely my own work and I fully understand the consequences of plagiarism. I understand that
making a false declaration is a form of malpractice.

Student’s signature Toan

Grading grid

P2 P3 P4 P5 M2 M3 M4 D2 D3 D4
❒ Summative Feedback: ❒ Resubmission Feedback:

Grade: Assessor Signature: Date:

Lecturer Signature:
 Table of Contents
A. Introduction. .......................................................................................................................................... 5
B. Content. .................................................................................................................................................. 6
I. Programming models. ....................................................................................................................... 6
1. Structured/Procedural Programming Paradigm. ....................................................................... 6
2. Object Oriented Programming..................................................................................................... 7
3. Event-driven programming. ......................................................................................................... 8
4. The relationship between 3 programming models...................................................................... 9
I. IDE Algorithm Settings. .................................................................................................................. 10
1. Problem definition. ...................................................................................................................... 11
2. Program function. ........................................................................................................................ 12
a) Login. ............................................................................................................................................ 12
b) Class Customer.cs ........................................................................................................................ 13
c) Class CustomerList.cs ................................................................................................................. 15
d) Customer information. ................................................................................................................ 18
3. Running Program. ....................................................................................................................... 23
II. Debugging Process ........................................................................................................................... 27
1. Debugging Process Definition. .................................................................................................... 27
2. Describe the debugging process in your program. ................................................................... 28
III. Code Writing Standards. ................................................................................................................ 31
1. Define. ........................................................................................................................................... 31
a) Coding standard........................................................................................................................... 31
b) A coding standard has the following advantages for software development: ........................ 31
2. Standards for writing code used in the program. ..................................................................... 32
C. Conclusion............................................................................................................................................ 33
D. References. ........................................................................................................................................... 34
 Table of Figures
Figure 1 : SOURCE CODE OF FUNCTION "LOGIN"......................................................................................... 12
Figure 2 : SOURCE CODE OF FUNCTION EXIT OF LOGIN............................................................................... 12
Figure 3 : Class customer.cs ......................................................................................................................... 14
Figure 4 : Class CustomerList.cs.................................................................................................................... 15
Figure 5 : SaveToFile ..................................................................................................................................... 16
Figure 6 : LoadFormFile ................................................................................................................................ 18
Figure 7 : Customer ...................................................................................................................................... 18
Figure 8 : Add Function................................................................................................................................. 19
Figure 9 : Save Function ............................................................................................................................... 19
Figure 10 : OpenFile Function....................................................................................................................... 20
Figure 11 : Delete Function .......................................................................................................................... 21
Figure 12 : Search Function .......................................................................................................................... 21
Figure 13 : Exit Function ............................................................................................................................... 22
Figure 14 : lvCustomer Function .................................................................................................................. 22
Figure 15 : RUNNING PROGRAM LOGIN...................................................................................................... 24
Figure 16 : Use the exit button in the login section ..................................................................................... 24
Figure 17 : Use the add button in the information entry............................................................................. 25
Figure 18 : Use the save button in the information entry ........................................................................... 25
Figure 19 : Use the Delete button in the information entry ........................................................................ 26
Figure 20 : Use the Search button in the information entry ........................................................................ 26
Figure 21 : Use the Exit button in the information entry ............................................................................. 27
Figure 22 : Setting breakpoints .................................................................................................................... 28
Figure 23 : Starting the debugging ............................................................................................................... 29
Figure 24 : Step Over .................................................................................................................................... 29
Figure 25 : Step Into ..................................................................................................................................... 30
Figure 26 : Step Out ...................................................................................................................................... 30
Figure 27 : An example of code using naming conventions......................................................................... 32
Figure 28 : An example of code formatted with layout conventions .......................................................... 33
A. Introductions.

In the quickly changing business environment of today, efficient product management is essential to
the success and expansion of businesses in a variety of industries. Software solutions act as a crucial
facilitator to optimize and streamline this vital process. This thesis sets out on a quest to create a user-
friendly Windows Form application with a product management focus using C#. The program
attempts to give businesses a single platform to effectively manage their goods, characteristics, and
related duties.

In every industry, from retail and manufacturing to e-commerce and logistics, the significance of
product management software cannot be overstated. It empowers organizations to organize inventory,
track product attributes, facilitate cross-functional collaboration, monitor sales and performance, and
enhance customer satisfaction. With such software at their disposal, companies can ensure smooth
operations, accurate data management, and strategic decision-making, giving them a competitive edge
in their markets.

The primary objectives of this thesis revolve around the development of a robust and user-friendly
product management application. We aim to implement a data management system that ensures the
accuracy and security of product-related information. Our focus also lies in designing an intuitive user
interface with clear navigation and visual elements, promoting ease of use for both technical and non-
technical users.

The report will also provide a thorough methodology, including the research strategy as well as the
technologies and techniques employed throughout the development process. To ensure a thorough
grasp of the application's structure, the system design section will look into the application's
architecture, data models, and user interface design.

The implementation section, which will appear as we go along and feature code snippets and solutions
to major roadblocks, will give a step-by-step explanation of the application development process.
Comprehensive testing and debugging techniques, which are described in the testing and debugging
section, will be used to guarantee the stability and dependability of the program.

The findings and assessment section will evaluate the app's functionality, usability, and success in
achieving the specified goals. We will emphasize the contributions of our study to the field of product
management software development and suggested areas for future improvements after drawing
conclusions from our findings.
By creating a robust and user-centered Windows Form application using C#, this thesis seeks to make
a significant contribution to the field of product management software. This application has the ability
to boost productivity and success in a variety of sectors by meeting the demands of businesses in better
managing their products.

B. Content.
I. Programming models.
1. Structured/Procedural Programming Paradigm.

The structured/procedural programming paradigm is a fundamental approach in software

development that breaks down programs into smaller, more manageable subroutines. This
programming model revolves around dividing complex tasks into smaller, coherent parts, making
the overall program easier to understand, maintain, and debug.

At the heart of structured programming is the top-down design approach, where the program's flow
is orchestrated by a central main program that calls various subroutines to execute specific tasks.
These subroutines can be further divided into smaller functions, enabling a hierarchical structure
that simplifies the development process.

One of the key strengths of structured programming lies in its emphasis on algorithmic thinking.
By focusing on the task at hand and breaking it down into smaller, well-defined steps, developers
can tackle intricate problems with greater clarity and efficiency. This methodical approach fosters
code reusability, as subroutines can be used across multiple parts of the program, promoting
modularity and reducing redundancy.

Moreover, the structured/procedural paradigm facilitates team collaboration. By organizing code

into distinct and logical units, different team members can work on separate functions
independently, minimizing code conflicts and promoting parallel development. Additionally, the
use of shared data allows seamless data exchange between functions, ensuring consistency and
coherence throughout the program.

However, as with any programming paradigm, structured programming also has its limitations.
When a program grows in size and complexity, managing numerous interrelated subroutines can
become challenging. The hierarchical structure, while beneficial for clarity in smaller programs,
may lead to decreased readability for those unfamiliar with the codebase. Moreover, modifications
to the program's structure may necessitate changes in multiple subroutines, increasing the potential
for errors.

To address some of the drawbacks of the structured/procedural paradigm, developers often employ
documentation and coding standards. Clear and comprehensive documentation helps maintain
program understanding, making it easier for others to comprehend the code. Additionally,
adherence to coding standards ensures consistent coding practices, enhancing readability and
maintainability.

In conclusion, the structured/procedural programming paradigm remains a prominent and effective

approach in software development. Its emphasis on algorithmic thinking, modularity, and code
reusability makes it invaluable for tackling complex tasks and enhancing program clarity. By
addressing the challenges posed by larger programs through documentation and coding standards,
developers can fully harness the strengths of this programming model to create robust and
maintainable software solutions.

2. Object Oriented Programming.

Object-oriented programming (OOP) is a revolutionary programming paradigm that revolves

around the concept of objects, emphasizing data rather than just logic. This paradigm has
transformed the way developers approach software design and development, providing a powerful
framework for creating reusable, extensible, and maintainable code.

At the heart of OOP lies the notion of abstraction, which simplifies the complexity of systems by
breaking them down into smaller, more manageable components. This involves creating objects
that represent real-world entities, while abstracting away the intricate details of their
implementation. By modeling the real world in code, developers can better understand and
organize their programs, leading to more efficient and intuitive designs.

Inheritance is another cornerstone of OOP, empowering developers to create new classes based on
existing ones. This powerful mechanism allows for the creation of class hierarchies, where derived
classes inherit properties and behaviors from their parent classes. Inheritance promotes code reuse,
enabling developers to build upon existing code without reinventing the wheel, and fostering the
creation of well-structured and modular systems.

Encapsulation complements the idea of abstraction by concealing the internal details of an object's
implementation from other objects. By encapsulating an object's state and methods, developers can
protect its integrity and control access to its data. This not only ensures that objects remain in a
consistent state but also reduces the likelihood of unintended interactions and bugs, enhancing the
overall reliability of the software.

Furthermore, polymorphism is a defining feature of OOP, enabling objects to take on multiple

forms or behaviors based on the context in which they are used. Through interfaces and abstract
classes, developers can create flexible and reusable code that can adapt to different situations
without the need for explicit type checking. This dynamic behavior allows for code that is both
adaptable and maintainable, particularly in situations where different implementations of the same
functionality are required.
The advantages of OOP are manifold. By promoting modularity and reusability, OOP leads to
faster development times and reduced code complexity. Developers can create libraries of classes
and objects that can be easily integrated into various projects, streamlining the development
process and fostering code consistency. Additionally, the hierarchical nature of OOP enables
developers to manage complex systems more effectively, facilitating team collaboration and
project scalability.

However, OOP is not without its challenges. Beginners may find it initially more difficult to grasp
the concepts of objects and classes, and the design of well-structured object-oriented systems may
require additional time and effort. Moreover, if not used judiciously, OOP can lead to overly
complex code, potentially reducing code efficiency and increasing maintenance overhead.

Despite these challenges, OOP remains a highly favored programming paradigm in the software
development community. Many modern programming languages, such as Java, C++, and Python,
embrace and enhance OOP concepts, providing developers with powerful tools to craft robust,
scalable, and adaptable applications. As software systems continue to evolve in complexity, OOP
will undoubtedly continue to play a central role in shaping the future of software engineering.

However, OOP also has some disadvantages. It can be more difficult to learn and understand than
other programming paradigms, especially for beginners. In addition, creating well-designed object-
oriented systems can require more time and effort than other approaches. Finally, some critics
argue that OOP can lead to overly complex code if not used carefully.

Despite its drawbacks, OOP remains a popular and widely used programming paradigm,
particularly in the development of large, complex software systems. Many modern programming
languages, such as Java, C++, and Python, support OOP concepts and provide developers with the
tools needed to create robust, scalable applications.

3. Event-driven programming.

Event-driven Event-driven programming, a dynamic programming paradigm, empowers software

systems to respond to events generated by the user or the system. These events, such as mouse
clicks, button presses, or keystrokes, act as signals that guide the flow of the program. By
designing applications to be event-driven, developers can create interactive and highly responsive
user interfaces that offer immediate feedback to users, enhancing the overall user experience.

A fundamental aspect of event-driven programming is the use of event handlers, essential

functions or methods that are invoked when a specific event occurs. Event handlers take charge of
processing the event and executing the corresponding actions. They are registered with the system
or user interface elements, like buttons or text boxes, establishing a direct link between user
interactions and application responses.
One of the notable strengths of event-driven programming lies in its ability to create modular and
reusable code. By designing event handlers to be generic and adaptable, developers can avoid code
duplication and increase code maintainability. This fosters the creation of flexible software
components that can be easily integrated into different parts of the application, promoting code
reusability and streamlining development efforts.

Furthermore, event-driven programming plays a pivotal role in crafting highly interactive graphical
user interfaces (GUIs). Users expect modern applications to be responsive to their actions, and
event-driven systems excel at delivering this responsiveness. By promptly reacting to user events,
such as button clicks or mouse movements, applications can provide real-time feedback, enriching
the user experience and driving user engagement.

Nonetheless, event-driven programming does present certain challenges. One of the primary
difficulties lies in debugging and testing. As the program's flow is contingent on events, recreating
specific scenarios for debugging purposes can be arduous, especially when dealing with complex
event interactions. Moreover, effectively testing all possible paths and edge cases can prove
intricate, necessitating thorough testing strategies to ensure robust and reliable event handling.

Additionally, event-driven programming can be perceived as more complex, particularly for

beginners in software development. Understanding the flow of the program and handling the
sequence of events can be challenging without a solid grasp of the underlying event-driven
architecture. However, as developers gain familiarity with this paradigm and its nuances, its
advantages in creating responsive, interactive applications become increasingly apparent.

In conclusion, event-driven programming is a powerful paradigm that empowers software systems

to react dynamically to user and system events. Its focus on creating interactive user interfaces and
modular, reusable code makes it an ideal choice for building engaging and efficient applications.
Though debugging and testing can pose challenges, and the learning curve may be steeper for
newcomers, mastering event-driven programming allows developers to craft sophisticated and
user-centric software systems that delight users and drive technological innovation.

4. The relationship between 3 programming models.

Procedural programming has long been favored as an introductory approach to teaching

programming concepts to beginners. By decomposing problems into smaller, more manageable
pieces, beginners can grasp fundamental programming principles without getting overwhelmed by
complexity. However, as software systems grow in size and sophistication, procedural
programming's limitations become apparent, making it less suitable for building larger, real-world
applications.
Object-oriented programming (OOP), on the other hand, shines when tackling complex and
expansive projects. OOP's emphasis on organizing code around objects and their interactions
enables developers to create well-structured, modular systems that are easier to understand,
maintain, and extend. With its ability to encapsulate data and behavior within objects, OOP
promotes code reusability and fosters collaborative development. Nonetheless, despite its extensive
application in various domains, OOP might not have been fully harnessed for real-world scenarios
due to potential misinterpretations or suboptimal implementations.

Enter event-driven programming, a compelling paradigm that complements OOP and finds its
stronghold in designing user interfaces and responsive applications. By tailoring programs to
respond to user inputs and system events, event-driven programming delivers interactive user
experiences that users have come to expect. It thrives in conjunction with OOP, where events
trigger object behaviors and facilitate seamless interactions. While event-driven programming
thrives in creating user-friendly interfaces, it may not have been exclusively adopted for broader
real-world applications, as these applications often require a more comprehensive combination of
paradigms.

To address the diverse and intricate challenges of creating real-world applications, developers
often embrace a hybrid approach, blending object-oriented and event-driven paradigms. This
amalgamation allows for the best of both worlds, enabling the construction of complex, scalable
systems that remain responsive and user-centric. With object-oriented design providing the
foundation for robustness and maintainability, event-driven programming breathes life into these
applications, ensuring that user interactions trigger appropriate actions in an efficient and logical
manner.

By fusing OOP's modularity and code reuse capabilities with the interactive nature of event-driven
programming, developers can deliver sophisticated applications that cater to real-world demands.
Through seamless integrations, this combination enables the creation of comprehensive software
solutions, ranging from intricate business applications to interactive multimedia interfaces.

In conclusion, while procedural programming serves as a valuable stepping stone for beginners, its
limitations make it less suitable for building larger real-world applications. Object-oriented
programming rises to prominence, offering an organized and scalable approach to tackle complex
problems. Event-driven programming thrives in delivering interactive user interfaces, often in
conjunction with object-oriented designs. Nonetheless, to develop sophisticated real-world
applications, the synergistic combination of object-oriented and event-driven paradigms proves
indispensable, providing developers with the tools to craft resilient, user-centric software systems
that leave a lasting impact in the modern digital landscape.

I. IDE Algorithm Settings.

1. Problem definition.

Customer management applications are sophisticated software solutions meticulously crafted to

facilitate seamless customer data management and interaction tracking for businesses. These
powerful applications act as digital repositories, enabling businesses to store vital customer
information, including names, phone numbers, purchase history, product prices, and details of
products purchased by each customer.

The primary objective of customer management applications is to elevate customer service and
streamline interactions. By centralizing customer information, these applications empower
businesses to deliver personalized and attentive customer service. They offer a comprehensive
view of customer interactions, allowing customer service representatives to cater to individual
needs and preferences, fostering long-lasting relationships with clients.

In addition to enhancing customer service, these applications serve as invaluable tools for driving
sales growth. Through advanced data analytics and reporting features, businesses can glean
valuable insights from customer data. Analysis of customer behavior and purchasing patterns helps
identify trends and untapped opportunities, enabling businesses to devise tailored marketing
strategies and boost sales performance.

Among the array of features offered by customer management applications are contact
management, task management, sales tracking, reporting, and analytics. These functionalities cater
to businesses of all sizes, accommodating the needs of small startups to large corporations. The
customizable nature of these applications ensures that businesses can tailor the software to meet
their specific requirements and operational processes.

Customer management applications play a pivotal role in the modern business landscape,
revolutionizing the way businesses interact with and understand their customers. By leveraging the
power of data, these applications facilitate informed decision-making, empowering businesses to
stay agile in a rapidly changing market.

The comprehensive insights gained from customer data not only aid in enhancing customer service
and boosting sales but also enable businesses to predict customer needs and preferences. Armed
with this foresight, businesses can anticipate market demands, fine-tune their product offerings,
and stay ahead of the competition.

In conclusion, customer management applications are a critical component of businesses striving

for excellence in customer service and sales growth. Through efficient data management and
analysis, businesses can transform customer interactions into opportunities for sustainable growth
and success. These applications epitomize the modern approach to customer-centricity, where
data-driven strategies pave the way for customer satisfaction and business prosperity. As
businesses continue to evolve, customer management applications remain at the forefront of
innovation, empowering businesses to forge lasting connections with their customers and thrive in
the dynamic digital era.

2. Program function.
a) Login.

Figure 1 : SOURCE CODE OF FUNCTION "LOGIN"

Figure 2 : SOURCE CODE OF FUNCTION EXIT OF LOGIN

Upon launching the customer management software, users are presented with two key options:
logging in or exiting the program. This intuitive interface aims to streamline user interactions and
provide a seamless experience. When opting to log in, users are prompted to enter their account
credentials - a crucial step in ensuring data security and access control.To ensure data integrity, the
application enforces stringent validation checks on the entered account and password. If the user
inputs incorrect credentials, a prompt gently guides them to re-enter the accurate information. This
failsafe mechanism mitigates the risk of unauthorized access, reinforcing the software's commitment
to safeguarding sensitive customer information.
Upon successful login, users are swiftly transitioned to the second page, where a wealth of customer
management features awaits. Here, users can effortlessly manage customer data, track interactions,
and leverage data analytics to glean actionable insights. The software's user-friendly design
encourages intuitive navigation, empowering users to engage with the platform efficiently.

In addition to the essential login functionality, the software extends further convenience by offering
a smooth exit option. Users are granted the freedom to terminate their session gracefully, without
any hassle. Upon choosing to "exit the program," the software kindly seeks confirmation from the
user, ensuring that accidental exits are avoided.

Once the user confirms their decision to exit, the application gracefully closes, preserving any
unsaved data and contributing to a positive user experience. This thoughtful approach underlines the
software's commitment to user satisfaction and data protection.

The login and exit features in the customer management software hold paramount importance in
today's data-driven landscape. By mandating user authentication, the software erects a robust fortress
against unauthorized access, safeguarding customer information from potential breaches. Such
measures comply with data protection regulations and build trust between the software provider and
its users.

Additionally, the exit functionality reflects a customer-centric approach, respecting users' time and
preferences. Whether users need to quickly switch to other tasks or simply conclude their session,
the software's flexibility allows for seamless transitions.

In conclusion, the login and exit features in the customer management software serve as vital pillars
of security and user experience. The stringent yet user-friendly login process ensures that customer
data remains protected, while the hassle-free exit option respects users' preferences. This harmonious
balance between security and convenience positions the software as a dependable and customer-
centric tool, catering to the needs of modern businesses and their commitment to data protection and
user satisfaction.

b) Class Customer.cs
 Figure 3 : Class customer.cs

In this code snippet, we encounter a thoughtfully crafted class named "Customer," equipped with
five essential properties: Name, PhoneNumber, Time, ProductName, and ProductPrice. These
properties hold pertinent information about each customer, enabling efficient data organization and
retrieval.However, the true gem of this class lies in its method called "ToListViewItem," which
elevates its functionality to the next level. This ingenious method ingeniously transforms a
"Customer" object into a "ListViewItem" object with utmost ease and precision.

The magic unfolds as the "ToListViewItem" method deftly assembles a new string array,
meticulously curating the values of each property from the "Customer" object. This string array
becomes a vessel of invaluable data, ready to be molded into a "ListViewItem" object.In a masterful
stroke of programming prowess, this string array seamlessly takes center stage, birthing a brand-new
"ListViewItem" object. Bursting with the details of the "Customer" object, this new entity epitomizes
efficiency and elegance.Picture this code in action: envision a ListView dynamically populated with
a list of customers and their crucial information. The "ToListViewItem" method's brilliance comes
to fruition as each "Customer" object gracefully metamorphoses into a "ListViewItem," standing
ready to adorn the ListView control.

The implications are awe-inspiring - the ListView becomes a visual feast of customer data,
effortlessly navigable and infinitely valuable. Users can feast their eyes on a well-organized canvas,
each "ListViewItem" showcasing the essence of a "Customer" object.In the world of software design,
such finesse is a game-changer. The "ToListViewItem" method's ingenuity enables developers to
curate visually captivating user interfaces, enhancing user experiences and elevating the application's
appeal.Imagine a user interface brimming with a wealth of customer data, all encapsulated within
charming "ListViewItem" entities. This code takes the mundane and transforms it into an interface
that captivates users, ensuring that customer information is both accessible and delightful to interact
with.
In conclusion, the code featuring the "Customer" class and its marvelously crafted
"ToListViewItem" method is an ode to efficiency and elegance in software design. By adorning each
"Customer" object with the power of "ListViewItem" entities, developers unlock a world of
possibilities in data presentation and user interface design. This code stands as a testament to the
artistry of programming - where functional efficiency meets visual allure. With each "Customer"
object seamlessly transitioning into a "ListViewItem," software applications embrace a symphony
of data organization and user experience, leaving users enthralled and developers applauded.

c) Class CustomerList.cs

Figure 4 : Class CustomerList.cs

In the realm of C# programming, we encounter a remarkable gem known as the "CustomerList"

class, a powerful custodian of customer data. This class assumes the responsibility of managing a
dynamic list of customers, imbued with a host of functionalities that elevate its prowess to new
heights.

At the heart of this class lies an array of essential methods, each carefully crafted to cater to the
diverse needs of customer data management. The first awe-inspiring feature is the "AddCustomer"
method, a gateway to seamlessly append a new customer to the list. Picture this - with a single call
to "AddCustomer," a customer is ushered into the realm of the "CustomerList," effortlessly joining
the ranks of the data elite.But that's not all - the "CustomerList" class takes data preservation to a
whole new level with its "SaveToFile" method. Armed with this capability, developers can safeguard
the cherished list of customers in a secure and organized file. This method breathes life into data
persistence, ensuring that the customer data can survive the ebb and flow of application states, ready
to be resurrected when the time is right.

However, the pièce de résistance of this class is undoubtedly the "LoadFromFile" method. With a
stroke of brilliance, this method reaches into the depths of file archives, retrieving the precious list
of customers, and seamlessly reincorporating it into the "CustomerList." The convenience of this
functionality cannot be overstated - developers can breathe life into the "CustomerList" anew with a
mere flicker of code.Imagine a world where customer data flows gracefully between application
states, gracefully ushered into existence, and secured for the ages. This "CustomerList" class paints
that very picture, where customers are cherished, safeguarded, and seamlessly transitioned into and
out of the list with utmost finesse.

And there you have it - a C# masterpiece that epitomizes the essence of customer data management.
This "CustomerList" class stands as a testament to the artistry of software design, where efficiency
meets elegance, and data becomes a symphony of possibilities.

In conclusion, the "CustomerList" class is a tour de force in C# programming, empowering

developers with an array of functionalities to manage customer data with grace and ease. With
methods for adding, saving, and loading customers, this class stands as a paragon of data
organization and persistence. As developers harness the power of the "CustomerList," they pave the
way for software applications that embrace the essence of customer-centricity, where data is
celebrated, preserved, and effortlessly integrated. In the ever-evolving world of software design, the
"CustomerList" class shines as a beacon of excellence, ensuring that customer data remains at the
heart of every application's journey.

Figure 5 : SaveToFile

Within the realms of C# programming, we encounter a sophisticated masterpiece known as the

"CustomerList" class, a custodian of customer data par excellence. With its core foundation anchored
in the List object, this class assumes the noble duty of managing a dynamic roster of customers,
exuding a sense of grace and efficiency that sets it apart.At the heart of this class lies the illustrious
"AddCustomer" method, a gateway to a seamless customer addition process. With the sheer elegance
of a single call to "AddCustomer," a new customer is gracefully ushered into the ranks of the
"CustomerList," greeted with open arms and promptly embraced by the encompassing data
structure.Yet, the true brilliance of the "CustomerList" class is revealed in its "SaveToFile" method,
an unparalleled feat of data preservation. Armed with the knowledge of a file name, this method
performs a symphony of actions, orchestrating the meticulous writing of the customer list to a file in
CSV format - a format celebrated for its versatility and accessibility.

In this symphony of data, each line in the file becomes a delicate tapestry, capturing the essence of
a single customer, with their unique attributes gracefully separated by commas. The resulting CSV
file is a masterpiece of organization, immortalizing the customer list for posterity, ready to be
retrieved and resurrected whenever the call arises.With such ingenuity in place, developers can
confidently safeguard the customer list, ensuring that precious data remains unscathed in the face of
application state transitions or unexpected events. This seamless data persistence paints a picture of
reliability, where customer information is preserved for the ages, standing the test of time with
elegance and resilience.

Imagine a world where customer data flows seamlessly from application to file, meticulously
preserved in a format that exudes simplicity and clarity. This "CustomerList" class brings this vision
to life, where the interplay of data and code produces a symphony of organization, accessible and
refined.

In conclusion, the "CustomerList" class in C# programming is an epitome of data management

excellence. With its core reliance on the List object, customer data is embraced with grace,
seamlessly incorporated into the folds of the "CustomerList." The brilliance of the "SaveToFile"
method further solidifies its eminence, ensuring data preservation through elegant CSV file writing.
As developers harness the potential of the "CustomerList," they lay the foundation for applications
that celebrate the essence of data organization and resilience, where customer information becomes
an everlasting treasure, forever embraced and protected by the wings of code.
 Figure 6 : LoadFormFile

Each line in the CSV file that the LoadFromFile function reads yields a Customer object, which is
then used to retrieve the list of customers. The assumption is that the file format is the same as that
of the SaveToFile function. Prior to reading the file and adding the new customers to the list, the
procedure clears the current list of clients.

The class's list of customers may be found by reading the Customers property, which is read-only.

d) Customer information.

Figure 7 : Customer
In this line of code, the type CustomerList, a special class created elsewhere in the code, is declared
as a private instance variable called customerList.

The software will be able to maintain track of client information by using this variable to store a list
of client objects. Methods for adding, deleting, and gaining access to Customer objects are available
in the CustomerList class.

- Add Function :

Figure 8 : Add Function

When a user hits the "Add" button on the form, the btnAdd_Click_1 event handler method is
launched. When the user inputs their name, phone number, the name of the product, the price of the
product, and the time the consumer purchased it, a new string array row is created that contains the
data. After that, it uses the row array to generate a new ListViewItem object, which it then adds to
the lvCustomers ListView control.

In essence, the customer data input by the user in the text fields is added to a new row in the
lvCustomers ListView control using this code.

- Save Function :

Figure 9 : Save Function

When a user hits the application's "Save" button, the btnSave_Click function is activated. The
StreamWriter class is initially created by the method in order to write data to the "data.txt" file.
The data is then retrieved from each ListViewItem's sub-item by iterating over all ListViewItems in
the lvCustomers list view control. It uses the string to create a comma-separated string by
concatenating the text values of the sub-items.join approach.

The writer is used by the function to write each row of data to the "data.txt" file.WriteLine approach.
The function shows a message box to let the user know that the data has been successfully stored
after writing all the data. The Application comes last.The program is terminated by using the Exit()
function.

- OpenFile Function :

Figure 10 : OpenFile Function

This code block defines the functionality of the "Open" button in the customer management program.
When the button is clicked, the program reads the contents of a text file ("data.txt") and loads them
into the list view control on the form.

To start, all data is deleted from the list view. A StreamReader object is then built to read the file's
content. The software reads the file line by line and uses commas as delimiters to divide each line
into an array of strings. The list view is then updated to include each array as a new list view item.
The file is closed when all the lines have been read and appended, and the list view of the form is
then shown with the freshly loaded data.

- Delete Function :
 Figure 11 : Delete Function

The "Delete" button's user interface functionality is defined by this code. When the button is pressed,
the program checks to see whether anything is selected in the ListView control. If at least one item
is chosen, the code deletes the first item from the list that is selected. A message box asking the user
to choose a customer to remove will be displayed if no item is selected by the user. This makes it
simple for the user to remove a client from the client list shown in the ListView control.

- Search Function :

Figure 12 : Search Function

The btnSearch_Click event handler is called when the user clicks on the "Search" button in the form.
Its main purpose is to search for a customer's name in the list of customers displayed in the ListView
control, and select the corresponding item(s) if found.

The method first retrieves the search string entered by the user from the txtName text box. It then
iterates through each item in the lvCustomers ListView control and checks whether the first sub-
item (the name) of each item contains the search string in a case-insensitive manner. If a match is
found, the Selected property of the item is set to true, which highlights the item in the control. If no
match is found, the Selected property of the item is set to false.
Finally, if no matching records are found, a message box is displayed to inform the user.

- Exit Function :

Figure 13 : Exit Function

The purpose of this code is to display a message box asking the user whether they wish to close the
program. The program will shut down using the program.Exit() function if the user chooses "Yes."
The user's choice of "No" will cause the program to continue functioning. Confirm Exit is the
message box's title, and there are two checkboxes for the user to select from: "Yes" and "no," as well
as a question mark icon.

- lvCustomer Function :

Figure 14 : lvCustomer Function

This captivating C# code snippet unveils an event handler method of immense functionality,
adorning the ListView control named "lvCustomers" with a touch of magic. When a user selects an
item within the ListView, this enchanting method is triggered, orchestrating a symphony of data
retrieval and population across several TextBox and DateTimePicker controls.At its core, this
mesmerizing code checks if at least one item is selected in the ListView, meticulously verifying the
presence of selected items using the "SelectedItems.Count" property. If a selection is detected, the
method proceeds with grace and finesse, retrieving the index of the first selected item through the
"SelectedIndices" property.
With the index in hand, the method proceeds to unravel the treasures hidden within the selected
item's sub-items (or columns) using the "SubItems" property. Each sub-item reveals a valuable piece
of customer data, destined to find its place in the TextBox and DateTimePicker controls, illuminating
the user interface with rich customer information.The dance of data begins as the customer's name,
a gem among the sub-items, gracefully adorns the "txtName" TextBox control, empowering users to
witness the essence of the selected customer.

Next, the customer's phone number, a splendid find in the sub-items, elegantly makes its home in
the "txtPhoneNumber" TextBox control, ready to be dialed and connected with the outside
world.Meanwhile, the DateTimePicker control named "dtpTime" awaits the arrival of the customer's
order date and time, a precious gift from the sub-items, destined to be savored and appreciated by
users.In another corner of the interface, the "txtProductName" TextBox control eagerly welcomes
the customer's product name, yet another treasure within the sub-items, filling the air with
anticipation and intrigue.

Finally, the "txtProductPrice" TextBox control awaits the arrival of the customer's product price,
cloaked in a "$" symbol within the sub-items. The method, armed with the "Substring" and "Trim"
methods, gracefully removes the "$" symbol and any unnecessary spaces, leaving only the pure
essence of the product price.

In conclusion, this spellbinding C# code snippet unveils a masterful event handler method that brings
the ListView control "lvCustomers" to life. By capturing the user's selections and artfully retrieving
and displaying customer data across TextBox and DateTimePicker controls, the method elevates the
user interface with a symphony of customer information. This code embodies the essence of user
interaction and data presentation, illuminating the pathway to a truly captivating user experience. As
users select and view customer data, they embark on a journey of discovery, embraced by the magic
of code and the artistry of data representation.data

3. Running Program.
 Figure 15 : RUNNING PROGRAM LOGIN

Figure 16 : Use the exit button in the login section

Figure 17 : Use the add button in the information entry

Figure 18 : Use the save button in the information entry

Figure 19 : Use the Delete button in the information entry

Figure 20 : Use the Search button in the information entry

 Figure 21 : Use the Exit button in the information entry

II. Debugging Process

1. Debugging Process Definition.

Debugging, an integral aspect of the software development process, involves the art of unraveling
and resolving errors or bugs that may lurk within a program's code. This crucial endeavor demands
keen problem-solving skills, as developers embark on a quest to identify the root cause of issues,
analyze their behavior, and enact appropriate modifications to restore the program's intended
functionality.

Central to the art of debugging is the deployment of a debugging environment, a sacred realm where
developers can observe a program's behavior in a controlled setting. Within this sanctuary,
developers wield powerful tools to inspect and investigate any anomalies that arise. Setting
breakpoints at strategic code points, they can gracefully pause execution to examine the program's
inner workings and scrutinize its current state. In this process of scrutiny, log files and error messages
serve as valuable breadcrumbs, leading developers towards the elusive source of issues. Armed with
debuggers and profilers, they venture into the labyrinth of code to track down and confront any
lurking bugs.

The rewards of effective debugging are manifold. Swiftly identifying and rectifying errors,
developers are granted the gift of time saved and effort spared. The insight offered by debugging
tools surpasses manual testing, unveiling intricacies and subtleties that would otherwise remain
obscured. The fruits of diligent debugging blossom into software of superior quality and enhanced
reliability, ultimately enhancing the user experience and bolstering the reputation of the developers.

Yet, debugging transcends its pragmatic role; it also nurtures the spirit of improvement and growth
among developers. As they peer into the inner workings of their creations, they gain a deeper
understanding of their code's behavior. In this process of introspection, they recognize opportunities
for optimization, identifying areas where their code can be refined and enhanced. Armed with
newfound wisdom, developers embrace a cycle of continuous improvement, refining their craft and
elevating the efficiency and functionality of their software.

In conclusion, debugging stands as an indispensable pillar of software development, a process of

unmasking and resolving errors that empowers developers to create reliable, high-quality software.
It offers insights into program behavior, fosters the spirit of improvement, and serves as the guardian
of software integrity. As developers embark on the journey of debugging, they unveil the essence of
their creations, ensuring that their software shines brightly, free from the shadows of bugs and
brimming with the brilliance of impeccable design.

2. Describe the debugging process in your program.

Step 1: Placing breakpoints at key locations in the code where an error could occur. The debugger
will halt the execution of the program at a certain location in the code known as a breakpoint so that
you may inspect the status of the program at that time.

Figure 22 : Setting breakpoints

Step 2: Starting the debugging process. This can be done by selecting the Debug option from the
menu or toolbar, or by pressing a specific key combination. When the debugger starts, the program
will execute up to the first breakpoint and then stop.
 Figure 23 : Starting the debugging

Step 3: Analyzing the code to identify the problem. This may involve stepping through the code one
line at a time (using the Step Over or Step Into commands) to see how the program executes,
examining variable values, and looking for unexpected behavior.

- Step Over :

Figure 24 : Step Over

- Step Into :

Figure 25 : Step Into

- Step Out :

Figure 26 : Step Out

Step 4 : of the debugging process involves delving into the heart of the code, armed with newfound
knowledge of the problem's source. With keen insight, developers proceed to enact changes to the
code, carefully crafting solutions that address the root cause of the issue. This transformative phase
demands the skillful artistry of code modification, where variables may be adjusted, program flow
may be redirected, and algorithms may be fine-tuned to restore the program to its intended state.

However, the quest for perfection does not end with mere code adjustments. In Step 5, the code is
put through rigorous testing to ensure that the problem has been vanquished. With a meticulous eye,
developers scrutinize every nook and cranny of the program, examining its behavior under various
scenarios and usage patterns. Rigorous testing is the crucible in which the true efficacy of the bug
fixes is revealed, validating the success of the debugging efforts.

Throughout this arduous journey, meticulous documentation stands as a guiding beacon. Detailed
notes capture each step taken and every change made to the code, forming a comprehensive log of
the debugging process. These records serve as an invaluable asset, offering insights into the
development journey and providing a trail of breadcrumbs to retrace one's steps. Armed with this
wealth of knowledge, developers equip themselves to avoid similar pitfalls in the future and embark
on future debugging quests with a sense of wisdom and preparedness.

The art of debugging is a testament to the perseverance and skill of developers. It is a journey filled
with challenges and revelations, where code is molded and refined to stand resilient against the tide
of errors. Armed with the tools of analysis, code modification, and rigorous testing, developers bring
forth software that shines with the brilliance of reliability and functionality.

In conclusion, the art of debugging is a multi-step process that empowers developers to craft flawless
software. Step 4 entails skillful code modification, addressing the root cause of issues, while Step 5
validates the success of bug fixes through rigorous testing. Detailed documentation stands as a
treasure trove of insights, guiding developers towards future excellence. Embracing the debugging
journey with resolve and ingenuity, developers stand as guardians of software integrity, ensuring
that their creations emerge triumphant in the face of any challenge.

III. Code Writing Standards.

1. Define.
a) Coding standard

A set of instructions for writing source code for computer applications is known as a coding standard.
The aim of a coding standard is to guarantee that the source code is written consistently and is
straightforward to read, understand, and maintain. The grammar, naming conventions for variables
and functions, code organization, code formatting, and other rules are frequently outlined in coding
standards.

A coding standard seeks to improve source code quality, lessen errors and risks, improve
maintainability and scalability, and ensure uniformity within a team. Several well-known coding
standards include the Google Style Guide, Microsoft.NET Framework Design Guidelines, and
Python PEP 8.

b) A coding standard has the following advantages for software development:

Coding standards promote best practices including writing clear, maintainable code, which raises
the caliber of the code. Because the code is better quality and simpler to understand and change,
there is a lesser likelihood of adding bugs.
Consistency: By following a coding standard, the team produces code consistently, making it easier
to understand and assess each other's work. This improves the team members' capacity for
cooperation and communication.
Lower maintenance costs: Code that follows a standard is easier to maintain, which reduces the cost
and time necessary to make changes or fix problems.
Improved portability: Standards guarantee that code is easily portable to various systems or
languages without the need for significant alterations.
Increased code reuse: Standards encourage modular and reusable code, which cuts down on the
quantity of new code that must be produced and boosts code effectiveness.

In conclusion, adhering to a coding standard is crucial for writing high-quality, scalable, and
maintainable code.

2. Standards for writing code used in the program.

There are several coding standards that can be used in a program, such as:
Naming convention:
This standard outlines the naming conventions for variables, functions, classes, and properties. For
instance, variables are frequently given meaningful names and lowercase letter names, but functions
and classes are given names with the initial letter capitalized and camelCase, respectively.

Figure 27 : An example of code using naming conventions

Layout conventions:
 This standard specifies the formatting requirements for code, such as line breaks, indentation, and
space. Code can be structured to be more legible, for instance, by dividing large lines into many lines
or employing consistent indentation.

Figure 28 : An example of code formatted with layout conventions

Coding standards for comments are a set of rules and recommendations for adding comments and
annotations to the source code of a program. These standards make it simpler for programmers to
maintain, debug, and upgrade the application by assisting them in understanding the source code.

Coding conventions dictate that variables, functions, classes, and methods must be named precisely,
the code's purpose must be stated, comments must be placed on each lines of code, and annotations
must use certain symbols.

Code comments boost the security of the source code, make it simpler for other programmers to
comprehend and maintain the code, and aid in understanding the purpose of each code block.

C. Conclusion.

In conclusion, the process of debugging in software development is a vital and intricate journey that
empowers developers to create reliable and efficient software solutions. The journey begins with
identifying and understanding the problem, followed by careful analysis of the code's behavior and the
formulation of hypotheses. Developers then venture into the debugging environment armed with an
array of powerful tools to validate their hypotheses and uncover the root cause of issues.

As they delve into the heart of the code, developers may encounter various challenges and
complexities, but with perseverance and ingenuity, they identify the source of the problem. Armed
with this newfound knowledge, they proceed to implement precise and strategic fixes, modifying the
code, adjusting variables, and directing program flow to restore the software to its intended
functionality.
However, the quest for excellence does not end with mere code modification. Rigorous testing
becomes the crucible that validates the success of bug fixes, ensuring that the program emerges
resilient and dependable. Through meticulous scrutiny under various scenarios, developers ensure that
the problem has been vanquished, leaving no room for uncertainty.

Throughout this process, detailed documentation serves as a faithful companion, capturing each step
taken and every change made to the code. These comprehensive notes become a valuable asset,
guiding developers in their future endeavors and providing insights into the development journey.

The art of debugging is a testament to the skill and dedication of developers. It is a journey filled with
challenges, revelations, and growth. With each bug resolved, developers refine their craft and
strengthen their understanding of software behavior.

Ultimately, debugging stands as a crucial pillar in software development, shaping software of superior
quality and reliability. It empowers developers to create solutions that stand resilient in the face of
challenges and bring delight to users. The art of debugging is a true testament to the endless pursuit of
excellence in the world of software development.

D. References.

Object-oriented programming pros and cons. [online] Available at : https://vn.got-it.ai/blog/phuong-

phap-lap-trinh-huong-doi-tuong-va-cac-uu-nhuoc-diem

What is OOP? pros and cons of OOP . [online] Available at: https://wikisecret.com/oop-la-gi-uu-diem-
va-nhuoc-diem-cua-lap-trinh-huong-doi-tuong-oop.htmls

Procedural, object-oriented, and event-setting relationships. [online] Available at :

https://www.quora.com/What-are-the-relationships-between-programming-procedural-object-
Oriented-and-event-Driven-paradigms

VisualStudio 2022 . [online] Available at : https://docs.microsoft.com/en-

us/visualstudio/debugger/debugger-feature-tour?view=vs-2022

Visual Studio 2022 . [online] Available at :

https://en.wikipedia.org/wiki/Microsoft_Visual_Studio#:~:text=Built%2Din%20languages%20include
%20C,is%20available%20via%20plug%2Dins.)

Object-Oriented Programming Concepts Available at : https://www.geeksforgeeks.org/object-

oriented-programming-oops-concepts-in-java/
Introduction to Object-Oriented Programming Concepts Available at:
https://www.tutorialspoint.com/object_oriented_programming/object_oriented_programming_concept
s.htm

SOLID Principles of Object-Oriented Design Available at : https://stackify.com/solid-principles-

object-oriented-design/

Top Integrated Development Environments (IDEs) Available at : https://stackify.com/top-integrated-

development-environments-ides/

The 11 Best Code Editors Available in 2021 Available at :

https://www.shopify.com/partners/blog/best-code-editor