Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes

(ebook) (audiobook) (audiobook)

Autorzy:: Julia Lerman, Rowan Miller

Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes Julia Lerman, Rowan Miller - okładka ebooka

Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes Julia Lerman, Rowan Miller - okładka audiobooka MP3

Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes Julia Lerman, Rowan Miller - okładka audiobooks CD

Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 194
Dostępne formaty:: ePub

Mobi

+55 pkt

Ebook (55,24 zł najniższa cena z 30 dni)

~~64,99 zł~~ (-15%)
55,24 zł

Dodaj do koszyka lub Kup na prezent
Kup 1-kliknięciem

( 55,24 zł najniższa cena z 30 dni)

Przenieś na półkę

Do przechowalni

Take advantage of the Code First data modeling approach in ADO.NET Entity Framework, and learn how to build and configure a model based on existing classes in your business domain. With this concise book, you’ll work hands-on with examples to learn how Code First can create an in-memory model and database by default, and how you can exert more control over the model through further configuration.

Code First provides an alternative to the database first and model first approaches to the Entity Data Model. Learn the benefits of defining your model with code, whether you’re working with an existing database or building one from scratch. If you work with Visual Studio and understand database management basics, this book is for you.

Learn exactly what Code First does—and does not—enable you to do
Understand how property attributes, relationships, and database mappings are inferred from your classes by Code First
Use Data Annotations and the Fluent API to configure the Code First data model
Perform advanced techniques, such as controlling the database schema and overriding the default model caching

This book is a continuation of author Julia Lerman’s Programming Entity Framework, widely recognized as the leading book on the topic.

Wybrane bestsellery

Ebooka "Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka "Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes" posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolnych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video "Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes" zobaczysz:

Oceny i opinie klientów: Programming Entity Framework: Code First. Creating and Configuring Data Models from Your Classes Julia Lerman, Rowan Miller (0) Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.

Szczegóły ebooka

ISBN Ebooka:: 978-14-493-2384-4, 9781449323844
Data wydania ebooka:: 2011-11-18 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
Język publikacji:: angielski
Rozmiar pliku ePub:: 1.9MB
Rozmiar pliku Mobi:: 1.9MB

Kategorie

Kliknij, aby zgłosić błędnie przypisaną kategorię »

Informatyka » Programowanie » Inne - Programowanie

Spis treści ebooka

Programming Entity Framework: Code First
- SPECIAL OFFER: Upgrade this ebook with OReilly
- Preface
  - Audience
  - Contents of This Book
  - Conventions Used in This Book
  - Using Code Examples
  - Safari Books Online
  - How to Contact Us
  - Acknowledgments
- 1. Welcome to Code First
  - Modeling with EF Before Code First
  - Inception of Code First
  - Getting Code First to Developers in Between .NET Releases
  - Writing the CodeFirst
  - Managing Objects with DbContext
  - Using the Data Layer and Domain Classes
  - Getting from Classes to a Database
  - Working with Configuration
    - Configuring with Data Annotations
    - Configuring with the Fluent API
  - Creating or Pointing to a Database
  - What Code First Does Not Support
    - Choosing Code First
  - Learning from This Book
- 2. Your First Look at Code First
  - Introducing EF to the Domain Classes
  - Putting the Pieces Together in an Example
    - Convention for Table, Schema, and Column Names
    - Convention for Keys
    - Convention for String Properties
    - Convention for Byte Array
    - Convention for Booleans
    - Convention for One-to-Many Relationships
  - Overriding Convention with Configurations
    - Configuring with Data Annotations
  - Understanding How Model Changes Impact Database Initialization
    - Data Annotations and Validation-Aware UIs
  - Configuring Code First with the Fluent API
    - Organizing Fluent Configurations
  - Summary
- 3. Using Conventions and Configurations for Property Attributes
  - Working with Property Attributes in Code First
    - Length
    - Data Type
    - Nullability and the Required Configuration
  - Mapping Keys
    - Code First Convention Response to Unconventional Key Properties
    - Configuring the Key with Data Annotations
    - Using HasKey to Configure a Key Property in the Fluent API
  - Configuring Database-Generated Properties
    - Configuring Database-Generated Options with Data Annotations
    - Configuring Database-Generated Options with the Fluent API
  - Configuring TimeStamp/RowVersion Fields for Optimistic Concurrency
    - Code First Convention and TimeStamp fields
    - Using Data Annotations to Configure TimeStamp
    - Configuring TimeStamp/RowVersion with Fluent API
  - Configuring Non-Timestamp Fields for Concurrency
    - Configuring for Optimistic Concurrency with Data Annotations
    - Configuring for Optimistic Concurrency with Fluent API
  - Mapping to Non-Unicode Database Types
  - Affecting the Precision and Scale of Decimals
    - Convention for Precision and Scale
    - Data Annotations for Precision and Scale
    - Fluent Configuration for Precision and Scale
  - Working with Complex Types in Code First
    - Defining Complex Types by Convention
    - Configuring Unconventional Complex Types
      - Specifying complex types with Data Annotations
      - Specifying complex types with the Fluent API
    - Working with More Complicated Complex Types
  - Configuring Properties of Complex Types
    - Configuring Complex Types with Data Annotations
    - Configuring Complex Type Properties with the Fluent API
  - Summary
- 4. Using Convention and Configuration for Relationships
  - Working with Multiplicity
    - Configuring Multiplicity with Data Annotations
    - Configuring Multiplicity with the Fluent API
  - Working with Foreign Keys
    - Specifying Unconventionally Named Foreign Keys
      - Fixing foreign key with Data Annotations
      - Fixing foreign key with the Fluent API
  - Working with Inverse Navigation Properties
  - Working with Cascade Delete
    - Turning On or Off Client-Side Cascade Delete with Fluent Configurations
    - Setting Cascade Delete Off in Scenarios That Are Not Supported by the Database
  - Exploring Many-to-Many Relationships
  - Working with Relationships that Have Unidirectional Navigation
  - Working with One-to-One Relationships
    - Configuring One-to-One Relationships When Both Ends Are Required
      - Ensuring that the sample code honors the required Photo
      - Configuring one-to-one with the Fluent API
  - Summary
- 5. Using Conventions and Configurations for Database Mappings
  - Mapping Class Name to Database Table and Schema Name
    - Configuring Table and Schema Name with Data Annotations
    - Configuring Table and Schema Name with the Fluent API
  - Mapping Property Names to Database Columns
    - Modifying the Default Column Name with Data Annotations
    - Modifying the Default Column Name with the Fluent API
    - Affecting Column Names for Complex Types
  - Allowing Multiple Entities to Map to a Single Table: aka Table Splitting
    - Mapping to a Common Table using Data Annotations
    - Splitting a Table Using the Fluent API
  - Mapping a Single Entity Across Multiple Tables
  - Controlling Which Types Get Mapped to the Database
    - Preventing Types from Being Included in the Model
      - Using Data Annotations to ignore types
      - Using Fluent Configuration to ignore types
  - Understanding Property Mapping and Accessibility
    - Scalar Property Mapping
    - Accessibility of Properties, Getters, and Setters
  - Preventing Properties from Being Included in the Model
    - Data Annotations for Ignoring a Property
    - Fluent Configuration for Ignoring a Property
  - Mapping Inheritance Hierarchies
    - Working with Code Firsts Default Inheritance: Table Per Hierarchy (TPH)
    - Customizing the TPH Discriminator Field with the Fluent API
    - Configuring Table Per Type (TPT) Hierarchy
    - Configuring for Table Per Concrete Type (TPC) Inheritance
    - Avoiding Mapping Exceptions with TPC
  - Working with Abstract Base Classes
  - Mapping Relationships
    - Controlling Foreign Keys Included in Your Class
    - Controlling Foreign Keys That Are Created by Code First
      - Controlling generated foreign keys with entity splitting
    - Controlling Many-to-Many Join Tables
  - Summary
- 6. Controlling Database Location, Creation Process, and Seed Data
  - Controlling the Database Location
    - Controlling Database Location with a Configuration File
    - Controlling Database Name with DbContext Constructor
    - Controlling Connection String Name with DbContext Constructor
    - Reusing Database Connections
    - Controlling Database Location with Connection Factories
      - Working with SqlConnectionFactory
      - Working with SqlCeConnectionFactory
      - Writing a custom connection factory
  - Working with Database Initialization
    - Controlling When Database Initialization Occurs
    - Switching Off Database Initialization Completely
    - Database Initializers Included in Entity Framework
    - Creating a Custom Database Initializer
    - Setting Database Initializers from a Configuration File
  - Using Database Initializers to Seed Data
  - Using Database Initialization to Further Affect Database Schema
  - Summary
- 7. Advanced Concepts
  - Mapping to Nontable Database Objects
    - Mapping to Updatable Views
    - Using Views to Populate Objects
    - Using Views to Populate Nonmodel Objects
    - Working with Stored Procedures
  - Removing Conventions
  - Taking Control of Model Caching
    - Understanding Model Caching
    - Overriding Default Model Caching
  - Working with the EdmMetadata Table
    - Coding Against EdmMetadata
    - Preventing Code First from Creating and Seeking EdmMetadata
  - Using Code First with ObjectContext
  - Summary
- 8. Whats Coming Next for Code First
  - Code First Migrations
  - Entity Framework Power Tools
    - Reverse Engineer Code First
    - Viewing a Code First Model
      - View Entity Data Model (Read-only)
      - View Entity Data Model XML
      - View Entity Data Model DDL SQL
    - Optimize Entity Data Model
- About the Authors
- SPECIAL OFFER: Upgrade this ebook with OReilly

pokaż cały spis treści