liveBook · Manning

Entity

An entity is a distinct, identifiable object, concept, participant, or record represented in a system's model or data.

How 14 Manning books explain it

Java Persistence with Spring Data and Hibernate epub

A business entity is an object representing a significant concept or state in an application's business domain.

How it is used
Models business concepts as independently identifiable objects that can be stored and retrieved.
How deep it goes
Explains class design, identity, mapping, managed updates, and detached-instance merging, including provider behavior.
Examples
Uses Message and Item mappings and an auction account-and-address model to illustrate entities.
What you can do after
Apply it via JPA and Hibernate to map domain classes, persist instances, and handle detached state.

Read how Java Persistence with Spring Data and Hibernate epub explains entity →

Building Web APIs with ASP.NET Core

An entity class is a C# class whose instances represent persistent data entities and their mapped attributes.

How it is used
Represents database records as C# objects used for CRUD operations and code-first schema creation.
How deep it goes
Works through annotated classes, relationship properties, composite keys, and DbSet exposure, without descending into EF Core internals.
Examples
Uses board-game, domain, mechanic, and link classes, plus HTTP requests that read or change entities.
What you can do after
Build it from scratch: define mapped C# entity classes and expose them through an EF Core DbContext.

Read how Building Web APIs with ASP.NET Core explains entity →

Clean Applications with Hexagonal Architecture

A domain object with an identity whose state and invariants are governed by domain rules.

How it is used
Places entities in the framework-free domain core to own business invariants during migration to hexagonal architecture.
How deep it goes
Defines identity and invariants, then details factory-based validation, boundary mapping risks, and testing responsibilities.
Examples
Uses Article and ArticleId to illustrate persistent identity, Title validation, and an aggregate referencing Author.
What you can do after
Build domain entities from scratch with factory-enforced invariants and keep their rules independent of adapters.

Read how Clean Applications with Hexagonal Architecture explains entity →

ASP.NET Core in Action, 3e

An entity is an application object whose structure and identity are mapped by an object-relational mapper to a database record.

How it is used
Uses application objects as the working representation of database data in a recipe-management API.
How deep it goes
Explains class mapping, conventions, relationships, model discovery, and insertion, while deferring many convention details and customizations.
Examples
Demonstrates Recipe and Ingredient classes, a many-to-one relationship, and creating linked rows through a recipe service.
What you can do after
Build it from scratch by defining entity classes, exposing them through DbContext, tracking objects, and saving mapped rows.

Read how ASP.NET Core in Action, 3e explains entity →

Authorization in Action

An entity is a person, organization, service, thing, or AI agent that can participate in relationships with a digital identity system.

How it is used
Uses entities to represent identity relationships and connect authorization policies to principals and resources.
How deep it goes
Defines entities and explains their preprocessing, schema design, and use in policy evaluation.
Examples
Illustrates inconsistent employment-status and ownership attributes across systems, and a new Folder entity introduced through schema updates.
What you can do after
Evaluate entity models for consistent attributes and appropriately narrow action types.

Read how Authorization in Action explains entity →

Grokking Relational Database Design

A distinct real-world object or concept that can be described by attributes and represented by data.

How it is used
Frames relational database design by turning requirement subjects into tables with records and attributes.
How deep it goes
Walks through entity identification, attributes, primary keys, data types, naming, and later relationship design.
Examples
Uses online-store products and a spaceship database containing brands, models, spaceships, dealers, and customers.
What you can do after
Build it from scratch by identifying entities, selecting attributes and keys, and assigning suitable data types.

Read how Grokking Relational Database Design explains entity →

Quarkus in Action

A persistence entity is a Java object whose state is mapped to and managed as records in a database through object-relational mapping.

How it is used
Represents reservation and inventory data as database-backed Java objects accessed through Panache or JPA.
How deep it goes
Works through entity annotations, ID choices, and access patterns, but does not develop a pure-JPA service.
Examples
Shows a reservation with an overlap method, a car with a generated ID, and an EntityManager persist call.
What you can do after
Build it from scratch as a Panache or plain JPA entity, then access it through a repository or EntityManager.

Read how Quarkus in Action explains entity →

100 SQL Server Mistakes and How to Avoid Them

An entity is a distinct type of thing represented in a data model and typically implemented as a table or related set of data.

How it is used
Organizes database data into objects, attributes, and relationships during schema design.
How deep it goes
Defines entities through ERDs and relationships, then connects them to keys and normalization without detailing implementation commands.
Examples
Uses sales orders, products, employees, and offices to demonstrate entity separation, relationships, keys, and duplication avoidance.
What you can do after
Evaluate schema structure by identifying entities, attributes, relationships, keys, and opportunities for normalization.

Read how 100 SQL Server Mistakes and How to Avoid Them explains entity →

Microsoft Azure in Action

An entity is a record-like item in Azure Table Storage containing properties and identifying keys.

How it is used
Stores flexible, fast-access records inside Azure Table Storage.
How deep it goes
Explains properties, JSON-defined schemas, composite identity, and partition placement, while deferring deeper partition planning.
Examples
Uses a book catalog entity with title and bookid properties and a GUID row key.
What you can do after
Builds and inserts an entity with PowerShell using Add-AzTableRow and a CloudTable reference.

Read how Microsoft Azure in Action explains entity →

Natural Language Processing in Action, Second Edition

An entity is a recognized semantic item in an utterance, such as a location, time expression, person, drug, or crop type.

How it is used
Uses entities to represent factual nodes in knowledge graphs and parameterize actions in conversational interfaces.
How deep it goes
Explains naming, normalization, triples, extraction, and slot distinctions, but stops short of general entity-linking methods.
Examples
Uses NELL triples, normalized names, weather locations and times, drug and crop types, and extracted proper names.
What you can do after
Apply entity representations to inspect knowledge-graph records and extract actionable parameters from chatbot utterances.

Read how Natural Language Processing in Action, Second Edition explains entity →

.NET in Action, Second Edition

A database entity is an application object or distinct unit of data whose state is represented and persisted in a database.

How it is used
Maps application objects to relational data sources and supports persistence, querying, and CRUD operations.
How deep it goes
Explains properties, relationships, conventions, generated tables, persistence, and eager loading, but defers detailed explicit configuration.
Examples
Uses Book, Rating, and Tag classes plus CatalogContext code that saves ratings and loads them with Include.
What you can do after
Apply it via EF Core by defining entity classes, modeling relationships, persisting objects, and loading related data.

Read how .NET in Action, Second Edition explains entity →

High Performance Unity Game Development

In this section's ECS representation, an entity is an index in data arrays that identifies an individual record.

How it is used
Maps an individual record to an array index within an ECS representation of data and logic.
How deep it goes
Defines entities as array indices and illustrates their use in enemy movement.
Examples
Uses index i to access and update enemy positions in an array.
What you can do after
Understand how an entity index selects a record during array-based movement.

Read how High Performance Unity Game Development explains entity →

Simple Object-Oriented Design: Create clean, maintainable applications

An entity is a domain object that represents a business concept through identifying attributes and behavior that maintains those attributes consistently.

How it is used
Models business concepts in the domain Model and maintains their attributes through entity behavior.
How deep it goes
Defines attributes, behavior, and layer-boundary risks, but stops short of implementation mechanics or detailed coding patterns.
Examples
Uses an Invoice class and the transformation of a repository-retrieved entity into a client-specific data structure.
What you can do after
Apply it by keeping business behavior with domain attributes and translating entities into client-specific structures.

Read how Simple Object-Oriented Design: Create clean, maintainable applications explains entity →

Go in Action, Second Edition

An entity is a domain object representing a distinct business concept with identity and associated data or behavior.

How it is used
Centers a shared domain model that API and worker modules can use independently of infrastructure.
How deep it goes
Defines Article and Feed fields and relates them to interfaces, stopping short of detailed entity behavior or persistence.
Examples
Uses Article for news articles and Feed for RSS/Atom feeds, with Fetcher, ArticleReader, and Storage interfaces.
What you can do after
Build it from scratch by defining portable domain structs and interfaces before implementing API, worker, or infrastructure details.

Read how Go in Action, Second Edition explains entity →

Also covered in

What to know first

Related concepts

Questions about entity

What is entity?

An entity is a distinct, identifiable object, concept, participant, or record represented in a system's model or data.

Which Manning books explain entity?

Java Persistence with Spring Data and Hibernate epub, Building Web APIs with ASP.NET Core, Clean Applications with Hexagonal Architecture, ASP.NET Core in Action, 3e, Authorization in Action, Grokking Relational Database Design, Quarkus in Action, 100 SQL Server Mistakes and How to Avoid Them and 6 more.

What should I know before learning entity?

Manning books that teach entity usually introduce JSON, SQL, foreign key and Java first.

What kinds of entity are there?

Kinds of entity include subject and cart item.

What are the parts of entity?

Entity includes attribute.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.