Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Programming C#

Programming C#

Build C# skills while understanding the runtime and platform they depend on.
by Jesse Liberty 2001 688 pages
3.68
195 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Learn C# as the language of a shared runtime, not an isolated tool

C# sits inside .NET. The book’s central idea is that C# is a way to build applications on a larger platform. The Common Language Runtime, or CLR, executes programs, manages memory, and coordinates services shared by .NET languages. C# code is compiled into Microsoft Intermediate Language, then translated into machine code by a just-in-time compiler as methods are needed. The Framework Class Library supplies reusable building blocks for data, networking, user interfaces, and more.

Interoperability is designed in. The Common Type System defines shared rules for types, while the Common Language Specification sets minimum requirements for languages that want to work together. In the book’s 2001 landscape, C#, Visual Basic .NET, Managed C++, and JScript .NET could use common libraries and interact across language boundaries.

Analysis

The useful shift is from asking what a language can do to asking what its runtime guarantees. Shared type rules make mixed-language systems more practical because components can agree on what an object, method, or value means. That bargain also creates dependence on the platform: portability is not automatic merely because code passes through an intermediate form. The platform must exist, and its libraries and runtime behavior must match the application’s needs.

Model domain concepts as objects, then protect their changing internals

Classes describe, objects act. A class defines the properties and behaviors of a kind of thing; an object is one instance with particular values. A Window class, for example, can describe location and drawing behavior, while an individual window has its own coordinates. Methods express behavior, fields hold internal state, and constructors put new objects into a valid initial condition.

Hide what may change. Properties let a class expose simple-looking values while controlling how they are read or updated. That matters if a value is later calculated or retrieved from a database instead of stored in a field. C# also distinguishes value types, commonly stored directly, from reference types, which refer to objects, and uses garbage collection to reclaim unreachable managed objects.

Analysis

Encapsulation is less about secrecy than about preserving room to change. A public field makes every client depend on the current storage design. A property creates a small boundary where validation, computation, or persistence can be introduced without rewriting callers. The distinction between value and reference types adds another design question: whether a copied value or a shared object is the behavior the problem actually requires.

Use inheritance for identity and interfaces for interchangeable capabilities

Inheritance captures an is-a relationship. A specialized class can reuse and extend a base class. The book’s window example has a ListBox derive from Window, inheriting common behavior while supplying its own drawing method. A virtual method lets the runtime choose the implementation that matches the object’s actual type, even when code handles it through a more general reference. Abstract classes define incomplete bases that cannot be instantiated directly.

Interfaces define contracts. An interface names methods and properties a class promises to provide, without dictating how it stores data or performs the work. C# permits a class to inherit from one class but implement multiple interfaces. A document might promise that it can be stored, compressed, or encrypted, letting clients use those capabilities without depending on one inheritance tree.

Analysis

This distinction helps prevent inheritance from becoming a storage closet for every shared behavior. A hierarchy should describe what a thing is; an interface can describe what it can do. That makes systems easier to extend when two classes need the same capability but do not belong in the same family. Contracts are only valuable when they stay stable, however. A vague interface can create as much coupling as a poorly chosen base class.

Let delegates route events without coupling senders to responders

A delegate packages a method shape. It specifies a return type and parameter list, then holds a reference to a method with that signature. A Pair class can delegate the decision about which item comes first to a method supplied by a Student or Dog class. The container does not need to know the sorting rule in advance; it only needs a compatible delegate.

Events use the same idea. A publisher raises an event when something happens, and any number of subscribers can register handlers. In the book’s clock example, a clock announces each change of second while one class displays the time and another logs it. The clock does not need to know what its subscribers do, and each subscriber can change independently.

Analysis

Delegates turn a hard-coded call into a replaceable relationship. That is the same architectural move behind callback systems and publish-subscribe designs: the sender announces an occurrence, while interested listeners decide how to react. The benefit is flexibility, not magic. Too many subscribers or unclear event ownership can make behavior difficult to trace, so event systems still need a legible account of who listens and when.

Use strong typing to catch mistakes early, and exceptions for failures

Types constrain valid operations. C# requires variables to have declared types and requires local variables to be assigned before use. Its Boolean values are distinct from integers, so a number cannot quietly stand in for true or false. Conversions that might lose information, such as narrowing an integer, must be explicit. These rules let the compiler reject some mistakes before the program runs.

Exceptions handle abnormal conditions. A try block marks code that may fail, catch handles selected exception types, and finally runs cleanup whether or not an exception occurs. The book distinguishes programming bugs and user errors from exceptional conditions such as a missing file. Custom exceptions can carry a useful message, help link, or inner exception that preserves the chain of failures.

Analysis

The compiler acts as an early reviewer, enforcing assumptions that otherwise survive until a user encounters them. Exceptions address a different problem: circumstances that cannot be fully prevented but should not make failure opaque. This separation is valuable because catching every exception can disguise programming defects, while validating every imaginable external condition can clutter the main logic. Good error handling makes the expected path clear and the failure path informative.

Choose collections by access pattern, and keep database work disconnected

Collections encode different needs. Arrays offer indexed access but have a fixed size. ArrayList grows as items are added; Queue processes items first in, first out; Stack processes them last in, first out; and a Hashtable associates keys with values. Interfaces such as IEnumerable and ICollection provide common ways to enumerate and inspect collections. Indexers can make a custom collection feel like an array while preserving control behind the interface.

ADO.NET separates data from the live connection. A DataSet holds a local group of tables and relationships. A data adapter retrieves rows into it, allowing an application to inspect or change data without keeping a database connection open continuously. Changes can later be checked, merged, and sent back. The model suits data-heavy applications, but programmers must still account for conflicting updates and database constraints.

Analysis

A collection is not just a container; it expresses how the program expects to use its contents. Choosing a queue for ordered work or a dictionary for key-based lookup clarifies intent and can avoid unnecessary searching. A disconnected data model makes network and database use more flexible, but it shifts responsibility toward reconciliation. Local edits are easy; deciding what to do when another process changed the same record is the harder design question.

Build interfaces with controls, then bind them to data and events

Forms turn interaction into components. Windows Forms use visual controls such as labels, buttons, and tree views. The designer can generate initialization code, while the programmer supplies event handlers for actions such as clicking Cancel or copying selected files. Web Forms apply a similar development style to browser-based applications, with server controls that produce standard HTML.

Web state needs special care. A web page is recreated on the server when a browser posts it back. ASP.NET provides a view-state mechanism that can preserve control values, and its event model distinguishes actions that post back immediately from changes that can wait. Data binding can populate a control from a DataSet, avoiding hard-coded lists that become stale when database contents change.

Analysis

The shared form metaphor makes desktop and web development feel related, but their operating conditions differ. A desktop control lives in a continuously running client, while a web control participates in a request and response cycle. The abstraction can simplify routine work, especially data binding, but it can also hide network costs and page lifecycle behavior. The developer still needs to know what runs on the client and what runs on the server.

Treat metadata and assemblies as the packaging and discovery layer

Assemblies package reusable code. An assembly is the unit of deployment, reuse, versioning, and security in .NET. It contains one or more modules, along with a manifest describing the assembly’s identity, contents, and references. A multi-module assembly can load parts only when needed, while a private assembly can live alongside one application without being installed globally.

Attributes make code inspectable. An attribute attaches metadata to a class, method, or assembly. The book’s BugFixAttribute example records a bug identifier, programmer, date, and comment. Reflection reads metadata at runtime, allowing a program or tool to discover types, inspect members, and invoke methods dynamically. Shared assemblies use strong names and version information to distinguish trusted, versioned components.

Analysis

Metadata gives code a description of itself, which supports tooling, discovery, and controlled reuse. Assemblies then turn that description into a deployment boundary. Together, they make components easier to inspect than opaque binaries with no declared identity. The cost is that deployment and versioning become part of program design. A component can be technically correct and still fail users if its identity, dependencies, or expected version are not managed carefully.

Design network and file I/O as streams, not as special cases

A stream is a flow of bytes. Files, memory, and network connections can all be treated as sources or destinations for streams. File and directory classes help locate and manage backing stores; Stream, StreamReader, and StreamWriter provide ways to read bytes or text. Buffered streams can reduce repeated access to a slower backing store, while asynchronous reads and writes let a program do other work while I/O proceeds.

Serialization turns objects into stream data. A formatter writes an object’s state into a chosen representation, such as binary data or SOAP-formatted XML. The CLR can serialize marked objects and their serializable members. Data that can be recomputed may be excluded and restored after deserialization. Isolated storage offers a per-application place to save user-specific settings without prescribing their format.

Analysis

Treating files and network connections through a common stream model reduces conceptual friction: the source changes, but many reading and writing patterns remain familiar. Asynchronous I/O is especially useful when waiting would otherwise freeze the rest of an application. Its callbacks require careful state management, though. A read completing is not the same as a full workflow completing, and every stage must account for errors, partial data, and cleanup.

Use asynchronous work for waiting, and synchronization for shared state

Threads allow work to overlap. The Thread class can start a method on another thread, while Join waits for that thread to finish and Sleep pauses the current one. Threads are useful when a program must keep responding while a long operation runs, but they add scheduling and coordination costs.

Shared state needs protection. If two threads read and update the same counter, both can act on an outdated value and produce incorrect results. Interlocked provides synchronized increment and decrement operations; a lock protects a broader critical section; Monitor offers explicit entry, exit, waiting, and signaling. Race conditions arise from uncontrolled ordering, while deadlocks occur when threads wait indefinitely on resources held by one another.

Analysis

Concurrency is not simply a speed setting. It changes what a program can safely assume about the order of operations. The counter example shows how ordinary read, modify, and write steps can interleave into a wrong result even though each line appears harmless alone. Synchronization restores a controlled sequence, but excessive locking can limit progress. The practical task is to protect shared state narrowly while leaving independent work free to proceed.

Make component boundaries explicit, from web services to legacy COM

Remote objects require a communication plan. Remoting marshals objects across context, application-domain, process, or machine boundaries. A proxy gives the client an object-like way to call a remote implementation, while channels carry messages and formatters encode them. Web services expose methods through web protocols, with SOAP messages and WSDL descriptions helping clients discover how to call them.

Older components can still participate. .NET can import ActiveX controls and COM type libraries through generated wrappers, and it can expose .NET classes for COM use. Platform invoke can reach unmanaged APIs when no managed alternative is available. These bridges preserve useful existing software, but each boundary adds format, lifetime, and compatibility concerns that ordinary in-process calls do not.

Analysis

The book’s unifying architectural theme is that boundaries are workable when their contracts are explicit. An interface describes what a component offers; a formatter describes how messages travel; a wrapper translates between runtime expectations. This makes gradual integration possible rather than demanding a clean rewrite. The limitation is equally important: a proxy can make a remote call look local, but it cannot remove latency, network failure, or version mismatch.

Analysis

Programming C# is both a language tutorial and a guided tour of the early .NET platform. Its progression is deliberate: establish syntax and types, build classes and interfaces, then move outward into forms, databases, web services, assemblies, remoting, threads, and I/O. The reader is not asked to learn C# in a vacuum. The language matters because it gives developers a route into a platform designed to unify application development and component reuse.

The book’s most durable contribution is architectural rather than syntactic. Strong typing makes contracts visible to the compiler. Classes and interfaces organize behavior into reusable units. Delegates separate an event’s sender from its responders. Streams standardize movement of data, while serialization and remoting extend object use across storage and process boundaries. Each technique draws a line between responsibilities, then supplies a mechanism for communication across that line.

That coherence also creates the book’s main difficulty as a summary. Its subject is not one compact thesis but an ecosystem of interdependent mechanisms. A short adaptation must preserve both the language foundation and the platform story without becoming a catalog of APIs. The selected principles therefore emphasize how to think about boundaries, state, and contracts, while retaining examples such as the clock event, disconnected DataSet, and marshaled shape object to make those ideas tangible.

The publication date matters. This is a 2001 account of C# and .NET, so specific tools, libraries, and development conventions belong to that period. The most useful reading today is neither to treat every API detail as timeless nor to dismiss the book as obsolete. Its value lies in showing how a language, runtime, libraries, and deployment model were designed to fit together. Readers can separate those enduring design questions from version-specific implementation details and use the book as a map of platform thinking.

Summary in 30 Seconds
C# runs within the .NET environment, where a shared runtime and class library support execution and reuse across languages. Classes and interfaces organize behavior, while delegates let event publishers communicate with independent subscribers. Strong typing catches some errors before execution, and exceptions handle failures. Collections suit different access patterns, while disconnected datasets reduce the need to keep database connections open. Streams unify file and network input, and threads require safeguards against race conditions and deadlocks.
Contains spoilers

Last updated:

Report Issue

Review Summary

3.68 out of 5
Average of 195 ratings from Goodreads and Amazon.

Programming C# receives mixed reviews, with an average rating of 3.67/5 from 193 readers. Some praise it as a solid foundation for learning C#, particularly for those familiar with other .NET languages. It's noted as a good reference for Windows application programming. However, some readers mistook it for a C++ book. The O'Reilly series is commended for its effectiveness in teaching new programming languages. A few reviewers found it helpful for quickly grasping C# concepts, while others skipped sections or used it primarily as a reference.

Your rating:
4.28
156 ratings
Want to read the full book?

Glossary

Common Language Runtime (CLR)

Executes managed applications

The execution environment at the heart of .NET. It loads and runs managed code, handles services such as memory management and garbage collection, and supports common rules for types and language interoperability. The book describes C# programs as compiling to intermediate language that the runtime converts to machine code when methods are needed.

Common Type System (CTS)

Shared rules for types

The .NET specification defining the types and type behaviors that participating languages share. It enables classes, interfaces, delegates, reference types, and value types to be represented consistently across the runtime. Because components follow the same type rules, a class created in one .NET language can be used or extended by another.

Common Language Specification (CLS)

Rules for language interoperability

A set of minimum rules that a language must follow to interoperate with other .NET languages. A CLS-compliant compiler produces components that can work with other compliant components and use the Framework Class Library. The specification supports cross-language development without requiring every language to expose every feature of every other language.

Microsoft Intermediate Language (MSIL)

Runtime-translated program instructions

The intermediate instruction format produced when a .NET program is compiled. C# and other .NET languages compile to this shared representation rather than directly to a particular processor’s machine code. At runtime, a just-in-time compiler translates methods into native instructions as they are called, reusing compiled code as the application runs.

Assembly

Deployment and versioning unit

A .NET unit of reuse, versioning, security, and deployment. An assembly may contain one or more modules and includes metadata describing its identity, types, resources, and references. Its manifest helps the runtime locate the code needed by an application. Assemblies can be private to one application or shared through the Global Assembly Cache.

Delegate

Type-safe method reference

A reference type that encapsulates a method with a specified return type and parameter signature. A delegate instance can hold a compatible method and invoke it without requiring the caller to know the method’s implementation in advance. Delegates support callbacks, event handling, and runtime selection of behavior.

Application domain

Lightweight execution boundary

A subdivision within a process that isolates managed application activity. An application domain can be created and unloaded independently and can provide a boundary for code and security. Objects may need to be marshaled when crossing between domains. The book presents domains as a lighter-weight way to isolate execution than using separate processes.

Marshaling

Preparing objects to cross boundaries

The process of making an object available across a boundary such as a context, application domain, process, or machine. An object may be marshaled by value, in which a copy is transferred, or by reference, in which a proxy provides access to the original object. Serialization and remoting provide mechanisms for carrying out this process.

Reflection

Inspecting program metadata

The ability of a program to examine metadata about assemblies, types, and members at runtime. Reflection can discover types, inspect methods and attributes, and invoke members dynamically. The book also presents Reflection Emit, which creates assemblies and types at runtime by generating intermediate instructions.

DataSet

Disconnected relational data cache

An in-memory representation of relational data that can contain multiple tables and relationships. ADO.NET fills a DataSet through a data adapter, allowing an application to inspect or modify data without maintaining a continuous database connection. Changes can be checked and later sent back to the source database.

Web Forms

Server-based web UI model

The ASP.NET model for building browser-based applications with server controls and event handlers. A Web Form combines an .aspx page for its interface with code that runs on the server. The server processes requests, manages control state through view state, and returns standard HTML to the browser.

FAQ

What's Programming C#: Building .NET Applications with C# about?

  • Comprehensive Guide: The book offers a detailed tutorial on C# programming within the .NET framework, covering both fundamental and advanced concepts.
  • Structured Learning: It is divided into three parts: C# language basics, writing .NET programs, and using C# with the .NET CLR, allowing for progressive learning.
  • Target Audience: Aimed at both beginners and experienced programmers, it provides insights into C# and .NET development, even for those with no prior programming experience.

Why should I read Programming C#: Building .NET Applications with C#?

  • Comprehensive Coverage: The book covers a wide range of topics, from basic syntax to advanced features like delegates and ADO.NET, making it a valuable resource.
  • Practical Approach: Each chapter includes practical examples and exercises, reinforcing concepts through hands-on learning.
  • Expert Guidance: Written by Jesse Liberty, a respected author, it offers insights and best practices to help avoid common pitfalls in C# programming.

What are the key takeaways of Programming C#: Building .NET Applications with C#?

  • Object-Oriented Programming: Emphasizes principles like encapsulation, inheritance, and polymorphism, crucial for effective C# programming.
  • .NET Framework Utilization: Guides on leveraging the .NET framework for building robust applications, including desktop and web applications.
  • Error Handling and Debugging: Covers exception handling and debugging techniques, essential for enhancing application quality.

What are the best quotes from Programming C#: Building .NET Applications with C# and what do they mean?

  • Structured Learning: "Begin at the beginning, and go on till you come to the end: then stop." This quote emphasizes a structured approach to learning programming.
  • C# Evolution: "C# is a new language, but it draws on the lessons learned over the past three decades." It reassures readers that existing programming knowledge is beneficial.
  • C# Purpose: "The goal of C# is to provide a simple, safe, modern, object-oriented, Internet-centric, high-performance language for .NET development." This encapsulates C#'s essence and purpose.

How does Programming C#: Building .NET Applications with C# explain object-oriented programming concepts?

  • Classes and Objects: Defines classes as blueprints for objects, emphasizing data and behavior encapsulation within classes.
  • Inheritance and Polymorphism: Explains creating derived classes and overriding methods for code reuse and flexibility, with polymorphism allowing derived class objects to be treated as base class objects.
  • Interfaces and Abstract Classes: Discusses differences and usage scenarios, crucial for designing extensible and maintainable code.

What are the C# language fundamentals covered in Programming C#: Building .NET Applications with C#?

  • Data Types and Variables: Discusses built-in data types, variable declaration, and initialization, essential for writing effective C# code.
  • Control Structures: Covers conditional statements and loops, crucial for creating dynamic and responsive applications.
  • Methods and Parameters: Explains method definitions, parameters, and method overloading, vital for structuring code and creating reusable components.

How does Programming C#: Building .NET Applications with C# approach event handling?

  • Delegates and Events: Explains the relationship between delegates and events, emphasizing their role in creating responsive applications.
  • Event Lifecycle: Covers subscribing to and unsubscribing from events, essential for managing event-driven programming.
  • Practical Examples: Provides examples of event handling, demonstrating implementation in real-world applications.

What is ADO.NET and how is it used in Programming C#: Building .NET Applications with C#?

  • Data Access Framework: ADO.NET provides a rich data access model for interacting with databases, covered extensively in the book.
  • Disconnected Architecture: Emphasizes ADO.NET's architecture for efficient data handling, useful for high-performance applications.
  • Practical Implementation: Includes examples of using ADO.NET to create DataSets, DataTables, and DataAdapters for data-driven applications.

How does Programming C#: Building .NET Applications with C# explain threading?

  • Threading Basics: Introduces threads as lightweight processes for multitasking within applications.
  • Synchronization Techniques: Covers locks and monitors to manage shared resource access and prevent race conditions.
  • Practical Examples: Provides code examples for creating and managing threads, ensuring practical application of concepts.

What is SOAP and how is it used in Programming C#: Building .NET Applications with C#?

  • Definition of SOAP: SOAP is a protocol for exchanging structured information in web services, based on XML.
  • Integration with .NET: Explains implementing SOAP in .NET applications for system communication over the internet.
  • WSDL and Discovery: Discusses using WSDL to describe services and how clients can discover and interact with them.

How does Programming C#: Building .NET Applications with C# address error handling?

  • Exception Handling Mechanisms: Covers throwing and catching exceptions, emphasizing robust error handling in development.
  • Best Practices: Advises on managing exceptions, including logging errors and providing user feedback.
  • Practical Examples: Demonstrates implementing try-catch blocks and managing exceptions in real-world applications.

What are the differences between structs and classes in C# as explained in Programming C#: Building .NET Applications with C#?

  • Value Types vs. Reference Types: Structs are value types stored on the stack, while classes are reference types stored on the heap, affecting memory management.
  • Inheritance: Structs do not support inheritance, limiting their use to simpler data structures, unlike classes.
  • Default Constructor: Structs cannot have a custom default constructor, while classes can, affecting initialization.

About the Author

Jesse Liberty is a prolific author and experienced software professional with a career spanning three decades. He has written numerous books and created online courses for platforms like Pluralsight and LinkedIn Learning. Liberty has held significant positions in the tech industry, including roles at Microsoft, AT&T, Citibank, and PBS. Currently working for CNH developing APIs, he is also a Microsoft MVP. His expertise covers various programming languages and technologies, with a focus on .NET and C#. Liberty's latest book on .NET MAUI was published in 2023, and he has another book on API development scheduled for 2025.

Download PDF

To save this Programming C# summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.41 MB     Pages: 22

Download EPUB

To read this Programming C# summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.38 MB     Pages: 26
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...