Programming Entity Framework. Building Data Centric Apps with the ADO.NET Entity Framework. 2nd Edition
- Autor:
- Julia Lerman
- Promocja Przejdź
- Ocena:
- Bądź pierwszym, który oceni tę książkę
- Stron:
- 920
- Dostępne formaty:
-
ePubMobi
Opis
książki
:
Programming Entity Framework. Building Data Centric Apps with the ADO.NET Entity Framework. 2nd Edition
Get a thorough introduction to ADO.NET Entity Framework 4 -- Microsoft's core framework for modeling and interacting with data in .NET applications. The second edition of this acclaimed guide provides a hands-on tour of the framework latest version in Visual Studio 2010 and .NET Framework 4. Not only will you learn how to use EF4 in a variety of applications, you'll also gain a deep understanding of its architecture and APIs.
Written by Julia Lerman, the leading independent authority on the framework, Programming Entity Framework covers it all -- from the Entity Data Model and Object Services to WCF Services, MVC Apps, and unit testing. This book highlights important changes for experienced developers familiar with the earlier version.
- Understand the core concepts you need to make the best use of the EF4 in your applications
- Learn to query your data, using either LINQ to Entities or Entity SQL
- Create Windows Forms, WPF, ASP.NET Web Forms, and ASP.NET MVC applications
- Build and consume WCF Services, WCF Data Services, and WCF RIA Services
- Use Object Services to work directly with your entity objects
- Create persistent ignorant entities, repositories, and write unit tests
- Delve into model customization, relationship management, change tracking, data concurrency, and more
- Get scores of reusable examples -- written in C# (with notes on Visual Basic syntax) -- that you can implement right away
Wybrane bestsellery
-
Promocja Promocja 2za1
The DbContext API captures Entity Framework’s (EF) most commonly used features and tasks, simplifying development with EF. This concise book shows you how to use the API to perform set operations with the DbSet class, handle change tracking and resolve concurrency conflicts with the Change Tracker API, and validate changes to your data with the Val- ePub + Mobi pkt
(37,99 zł najniższa cena z 30 dni)
55.24 zł
64.98 zł (-15%) -
Promocja Promocja 2za1
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 cont- ePub + Mobi pkt
(37,53 zł najniższa cena z 30 dni)
55.24 zł
64.98 zł (-15%) -
Promocja Promocja 2za1
If you use Entity Framework in Visual Studio 2008 and .NET 3.5, this is the book you want. Programming Entity Framework, 1st Edition offers experienced developers a thorough introduction to Microsoft's core framework for modeling and interacting with data in .NET applications. This hands-on tour provides a deep understanding of Entity Framework's a- ePub + Mobi pkt
(107,26 zł najniższa cena z 30 dni)
160.65 zł
189.00 zł (-15%) -
Promocja Promocja 2za1
Oto praktyczny, przystępnie napisany przewodnik, który stanowi wprowadzenie do pracy z technologią Blazor. Opisuje możliwości modeli Server i WebAssembly, przedstawia także krok po kroku proces powstawania aplikacji internetowej. Dzięki temu płynnie przejdziesz do tworzenia projektów Blazor, nauczysz się składni języka Razor, będziesz też weryfikować zawartość formularzy i budować własne komponenty. W tym wydaniu omówiono również generatory kodu źródłowego i zasady przenoszenia komponentów witryn utworzonych w innych technologiach do platformy Blazor. W trakcie lektury dowiesz się, jak tworzyć uniwersalne aplikacje za pomocą wersji Blazor Hybrid wraz z platformą .NET MAUI.- Druk
- PDF + ePub + Mobi pkt
(41,40 zł najniższa cena z 30 dni)
44.85 zł
69.00 zł (-35%) -
Promocja Promocja 2za1
To kolejne, mocno przebudowane wydanie popularnego przewodnika, dzięki któremu zaczniesz skutecznie programować w języku C#. Nabierzesz wprawy w programowaniu zorientowanym obiektowo, pisaniu, testowaniu i debugowaniu funkcji, implementowaniu interfejsów i zarządzaniu danymi. Zobaczysz, w jaki sposób API środowiska .NET realizuje takie zadania jak monitorowanie wydajności i jej poprawianie, jak również praca z systemem plików i serializacją. Wiedza zawarta w kolejnych rozdziałach pozwoli Ci tworzyć praktyczne aplikacje i serwisy z wykorzystaniem biblioteki ASP.NET Core, wzorca MVC i technologii Blazor.- Druk
- PDF + ePub + Mobi pkt
(53,90 zł najniższa cena z 30 dni)
53.90 zł
179.00 zł (-70%) -
Promocja Promocja 2za1
Nie trzeba siedzieć po uszy w programowaniu, by zauważyć pewną regułę: lwia część książek poświęconych temu zagadnieniu została napisana w podobny sposób. I nie chodzi o styl, środowisko czy język, lecz o strukturę. Prawidłowość tę zauważył Łukasz Sosna, który do zagadnienia programowania w języku C# i użytkowania środowiska .NET postanowił podejść w odmienny sposób. W najnowszej publikacji swojego autorstwa zatem skupia się na praktycznym wymiarze programowania, czyli używaniu dostępnych w oprogramowaniu Visual Studio 2022 komponentów zwanych kontrolkami.- Druk
- PDF + ePub + Mobi pkt
(29,94 zł najniższa cena z 30 dni)
32.43 zł
49.90 zł (-35%) -
Promocja Promocja 2za1
Po przyswojeniu zagadnień związanych z językiem C# i aplikacjami konsoli dowiesz się, jak tworzyć praktyczne aplikacje i usługi z wykorzystaniem biblioteki ASP.NET Core, a także wzorzec MVC i technologię Blazor. Zapoznasz się z metodami stosowania wielozadaniowości do poprawy wydajności i skalowalności aplikacji. Przeczytasz też, w jaki sposób ASP.NET Core ułatwia pracę wielu zespołów programistów. Poszczególne zagadnienia zostały zilustrowane dokładnie wyjaśnionymi przykładami kodu, a dodatkowe ćwiczenia pozwolą Ci na utrwalenie zdobytych umiejętności.- Druk
- PDF + ePub + Mobi pkt
(47,90 zł najniższa cena z 30 dni)
47.90 zł
159.00 zł (-70%) -
Promocja Promocja 2za1
Jeśli uczysz się programowania od niedawna i chcesz tworzyć aplikacje desktopowe przy użyciu technologii WPF, to jest to książka dla Ciebie! Z jej pomocą szybko rozpoczniesz pisanie programów. W ten sposób, tworząc kolejne aplikacje okienkowe, będziesz poznawać kluczowe możliwości tej platformy.- Druk
- PDF + ePub + Mobi pkt
(23,94 zł najniższa cena z 30 dni)
25.92 zł
39.90 zł (-35%) -
Promocja 2za1
From fundamental subjects to delivery, automation, containerization, and cloud-native development, you'll find all the necessary information to build modern web applications using ASP.Net Core 9.- pkt
W przygotowaniu
Powiadom mnie, gdy książka będzie dostępna -
Nowość Promocja Promocja 2za1
A comprehensive guide to learning .NET 7 Key Features Explore the new features and libraries introduced in .NET 7. Master the art of designing views in a .NET 7 application. Understand how to leverage the new .NET MAUI framework. Description .NET has transformed the landscape of software development with its versatility and widespread adoption. I- ePub + Mobi pkt
(71,91 zł najniższa cena z 30 dni)
76.49 zł
84.99 zł (-10%) -
Nowość Promocja Promocja 2za1
A practical guide to cross-platform app development with .NET MAUI and C# Key Features Get familiar with .NET MAUI, its associated libraries, and popular design patterns used in cross-platform app development. Learn how to design and implement visually appealing and interactive user interfaces in your .NET MAUI app. Deep dive into the process of c- ePub + Mobi pkt
(71,91 zł najniższa cena z 30 dni)
76.49 zł
84.99 zł (-10%) -
Nowość Promocja Promocja 2za1
Unleash the power of Excel for advanced data analysis, automation, and productivity Key Features Build a solid foundation in Excel by learning the basics, including the creation and formatting cells, sheets, and workbooks. Explore advanced Excel techniques, including formulas, data analysis, and VBA macros. Discover the potential of ChatGPT for Ex- ePub + Mobi pkt
(71,91 zł najniższa cena z 30 dni)
76.49 zł
84.99 zł (-10%) -
Nowość Promocja Promocja 2za1
Learn Blazor from the ground up, with step-by-step instructions and code examples Key Features Explore the ins and outs of Blazor architecture and gain a comprehensive understanding of its components. Dive deep into the intricacies of Blazor deployment, ensuring smooth and successful launches. Uncover valuable tips and tricks for optimizing perfor- ePub + Mobi pkt
(71,91 zł najniższa cena z 30 dni)
76.49 zł
84.99 zł (-10%)
Ebooka "Programming Entity Framework. Building Data Centric Apps with the ADO.NET Entity Framework. 2nd Edition" przeczytasz na:
-
czytnikach Inkbook, Kindle, Pocketbook, Onyx Booxs 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. Building Data Centric Apps with the ADO.NET Entity Framework. 2nd Edition" posłuchasz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolonych 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. Building Data Centric Apps with the ADO.NET Entity Framework. 2nd Edition" zobaczysz:
-
w aplikacjach Ebookpoint i Videopoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych z dostępem do najnowszej wersji Twojej przeglądarki internetowej
Szczegóły książki
- ISBN Ebooka:
- 978-14-493-9965-8, 9781449399658
- Data wydania ebooka :
- 2010-08-09 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@helion.pl.
- Język publikacji:
- 1
- Rozmiar pliku ePub:
- 7MB
- Rozmiar pliku Mobi:
- 7MB
- Zgłoś erratę
- Kategorie:
Programowanie » .NET - Programowanie
Spis treści książki
- Programming Entity Framework
- SPECIAL OFFER: Upgrade this ebook with OReilly
- Foreword
- Preface
- Who This Book Is For
- How This Book Is Organized
- What You Need to Use This Book
- This Books Website
- Conventions Used in This Book
- Using Code Examples
- Safari Books Online
- Comments and Questions
- Acknowledgments
- Author Note for Third Printing, August 2011
- Entity Framework 4.1 (Code First and DbContext) Has Released
- Entity Framework June 2011 CTP
- 1. Introducing the ADO.NET Entity Framework
- The Entity Relationship Model: Programming Against a Model, Not the Database
- The Entity Data Model: A Client-Side Data Model
- Entities: Blueprints for Business Classes
- The Backend Database: Your Choice
- Database Providers
- Access and ODBC
- Entity Framework Features: APIs and Tools
- Metadata
- Entity Data Model Design Tools
- Database-first design
- Model-first design
- Code generation
- Object Services
- POCO Support
- Change Tracking
- Relationship Management and Foreign Keys
- Data Binding
- n-Tier Development
- EntityClient
- The Entity Framework and WCF Services
- What About ADO.NET DataSets and LINQ to SQL?
- DataSets
- LINQ to SQL
- Entity Framework Pain Points Are Fading Away
- Programming the Entity Framework
- 2. Exploring the Entity Data Model
- Why Use an Entity Data Model?
- The EDM Within the Entity Framework
- Walkthrough: Building Your First EDM
- Inspecting the EDM in the Designer Window
- Entity Container Properties
- Entity Properties
- Entity Property Properties
- The Models Supporting Metadata
- Viewing the Model in the Model Browser
- Viewing the Models Raw XML
- CSDL: The Conceptual Schema
- EntityContainer
- EntitySet
- EntityType
- The Key element
- The Property elements
- The navigation properties
- Associations
- Navigation Property
- Navigation Properties That Return Collections
- SSDL: The Store Schema
- MSL: The Mappings
- Database Views in the EDM
- Summary
- 3. Querying Entity Data Models
- Query the Model, Not the Database
- Your First EDM Query
- Where Did the Context and Classes Come From?
- The ObjectContext class, SampleEntities
- The entity classes
- Where Did the Context and Classes Come From?
- Querying with LINQ to Entities
- Writing Your First LINQ to Entities Query
- Querying with Object Services and Entity SQL
- Why Another Way to Query?
- Entity SQL
- Entity SQL canonical functions
- The Parameterized ObjectQuery
- Querying with Methods
- Querying with LINQ Methods
- Chaining methods
- Querying with Query Builder Methods and Entity SQL
- Specifying the control variable
- Querying with LINQ Methods
- The Shortest Query
- ObjectQuery, ObjectSet, and LINQ to Entities
- Querying with EntityClient to Return Streamed Data
- EntityConnection and the Connection String
- EntityCommand
- ExecuteReader
- Forward-Only Access to the Fields
- Translating Entity Queries to Database Queries
- Pay Attention to the .NET Methods Impact on Generated SQL
- Avoiding Inadvertent Query Execution
- Summary
- 4. Exploring LINQ to Entities in Greater Depth
- Getting Ready with Some New Lingo
- Projections in Queries
- Projections in LINQ to Entities
- VB and C# Syntax Differences
- LINQ Projections and Special Language Features
- Anonymous types
- Implicitly typed local variables
- Implicit and explicit anonymous type creation
- Projections with LINQ Query Methods
- Using Navigations in Queries
- Navigating to an EntityReference
- Filtering and Sorting with an EntityReference
- Navigating to Entity Collections
- Projecting Properties from EntityCollection Entities
- Shaped results
- Flattened results
- Filtering and Sorting with EntityCollections
- Aggregates with EntityCollections
- Aggregates in LINQ to Entities
- Aggregates in LINQ Methods
- Joins and Nested Queries
- Joins
- Nested Queries
- Using a nested LINQ query as a projection
- Using a nested LINQ query as the collection to be queried
- Grouping
- Naming Properties When Grouping
- Chaining Aggregates
- Filtering on Group Conditions
- Shaping Data Returned by Queries
- Limiting Which Related Data Is Returned
- Loading Related Data
- Controlling Lazy Loading
- Disabling and enabling lazy loading programmatically
- Changing the default behavior for lazy loading
- Explicitly Loading Entity Collections and Entity References
- Loading the EntityReference
- Performance considerations with deferred loading
- Using the Include Method to Eager-Load
- How is the data shaped with Include?
- Accessing properties from an Include in the query
- Pros and Cons of Load and Include
- Controlling Lazy Loading
- Retrieving a Single Entity
- Retrieving a Single Entity with GetObjectByKey
- Finding More Query Samples
- Summary
- 5. Exploring Entity SQL in Greater Depth
- Literals in Entity SQL
- Expressing a DateTime Literal
- Expressing a Decimal Literal
- Using Additional Literal Types
- Projecting in Entity SQL
- DbDataRecords and Nonscalar Properties
- Projecting with Query Builder Methods
- Using Navigation in Entity SQL Queries
- Navigating to an EntityReference
- Filtering and Sorting with an EntityReference
- Filtering and Sorting with EntityCollections
- Aggregating with EntityCollections
- Using Entity SQL SET Operators
- Aggregating with Query Builder Methods
- Using Joins
- Nesting Queries
- Grouping in Entity SQL
- Returning Entities from an Entity SQL GROUP BY Query
- Filtering Based on Group Properties
- Shaping Data with Entity SQL
- Using Include with an ObjectQuery and Entity SQL
- Understanding Entity SQLs Wrapped and Unwrapped Results
- Entity SQL Rules for Wrapped and Unwrapped Results
- Digging a Little Deeper into EntityClients Results
- Summary
- Literals in Entity SQL
- 6. Modifying Entities and Saving Changes
- Keeping Track of Entities
- Managing an Entitys State
- Saving Changes Back to the Database
- Inserting New Objects
- Inserting New Parents and Children
- Deleting Entities
- Summary
- Keeping Track of Entities
- 7. Using Stored Procedures with the EDM
- Updating the Model from a Database
- Working with Functions
- Function Attributes
- Mapping Functions to Entities
- Mapping Insert, Update, and Delete Functions to an Entity
- Concurrency checking with Use Original Value and Rows Affected Parameter options
- Inspecting Mappings in XML
- Using Mapped Functions
- Mapping Insert, Update, and Delete Functions to an Entity
- Using the EDM Designer Model Browser to Import Additional Functions into Your Model
- Mapping the First of the Read Stored Procedures: ContactsbyState
- Using Imported Functions
- Avoiding Inadvertent Client-Side Processing
- Mapping a Function to a Scalar Type
- Mapping a Function to a Complex Type
- Summary
- 8. Implementing a More Real-World Model
- Introducing the BreakAway Geek Adventures Business Model and Legacy Database
- Creating a Separate Project for an EDM
- Inspecting and Cleaning Up a New EDM
- Modifying the Names of Entities and Properties
- Resolving Collisions Between Property Names and Entity Names
- Cleaning Up Navigation Property Names
- Setting Default Values
- Mapping Stored Procedures
- Using the Use Original Value Checkbox in Update Mappings
- Working with Many-to-Many Relationships
- Inspecting the Completed BreakAway Model
- Building the BreakAway Model Assembly
- Looking at the Compiled Assembly
- Splitting Out the Models Metadata Files
- Moving the schema files
- Summary
- 9. Data Binding with Windows Forms and WPF Applications
- Data Binding with Windows Forms Applications
- Creating a Windows Forms Application
- Using Windows Forms Data Sources
- Creating an Object Data Source for a Customer Entity
- Getting an Entitys Details onto a Form
- Adding Code to Query an EDM When a Form Loads
- Binding Without a BindingSource
- Adding an EntityCollection to the Form
- Displaying the Properties of Related Data in the Grid
- Allowing Users to Edit Data
- Editing Navigation Properties (and Shrinking the Query)
- Replacing the Navigation Property TextBoxes with ComboBoxes
- Adding New Customers
- Deleting Reservations
- Data Binding with WPF Applications
- Creating the WPF Form
- Creating the WPF Project
- Adding the Necessary Data Source Objects
- Inspecting the XAML and Code Generated by the Automated Data Binding
- XAML data-binding elements
- Adding Code to Query the EDM When the Window Loads
- Customizing the Display of the Controls
- Selecting an Entity and Viewing Its Details
- Adding Another EntityCollection to the Mix
- Working with a many-to-many relationship
- Modifying the code to eager-load the related activities
- Adding the Activities ListBox and binding it to the Trips ListBox
- Testing the application again
- Editing Entities and Their Related Data
- Using SortDescriptions to Keep Sorting in Sync with Data Modifications
- Adding Items to the Child EntityCollection
- Testing the new feature for adding activities
- The Last Task: Adding New Trips to the Catalog
- A few WPF tricks for a more interactive ListBox
- Coding the Add New Trip feature
- Testing the final version of the WPF demo
- Summary
- Data Binding with Windows Forms Applications
- 10. Working with Object Services
- Where Does Object Services Fit into the Framework?
- Processing Queries
- Parsing Queries: From Query to Command Tree to SQL
- Understanding Query Builder Methods
- Query builder methods and EntitySets
- From query builder methods to Entity SQL expressions
- Combining LINQ methods and query builder methods
- Analyzing a Query with ObjectQuery Methods and Properties
- ObjectQuery.ToTraceString
- ObjectQuery.CommandText
- ObjectQuery.Parameters
- ObjectQuery.Context
- Executing Queries with ToList, ToArray, First or Single
- Executing Queries with the Execute Method
- Overriding a Default Connection with ObjectContext.Connection
- Handling Command Execution with EntityClient
- Materializing Objects
- Managing Object State
- Using EntityKey to Manage Objects
- Merging Results into the Cache with MergeOptions
- Inspecting ObjectStateEntry
- Maintaining EntityState
- Managing Relationships
- Attaching and Detaching Objects from the ObjectContext
- ObjectContext.AddObject and ObjectSet.AddObject
- ObjectContext.Attach and ObjectSet.Attach
- ObjectContext.AttachTo
- Attaching and Detaching Objects from the ObjectContext
- Taking Control of ObjectState
- ObjectContext Methods
- ObjectStateManager Methods
- ObjectStateEntry State Methods for Managing State
- ObjectSet State Methods
- Sending Changes Back to the Database
- ObjectContext.SaveChanges
- SaveChanges returns an integer
- SaveChanges refreshes the state of tracked entities
- Affecting SaveChanges Default Behavior
- Overriding SaveChanges Completely
- Data Validation with the SavingChanges Event
- Concurrency Management
- Optimistic concurrency
- ConcurrencyMode
- OptimisticConcurrencyException
- Transaction Support
- ObjectContext.SaveChanges
- Implementing Serialization, Data Binding, and More
- Object Services Supports XML and Binary Serialization
- ObjectContext, ObjectStateManager, and ObjectStateEntry are not serializable
- Automatic serialization
- XML and DataContract serialization
- Binary serialization
- Serialization and object state
- Explicit serialization
- Object Services Supports Data Binding
- Object Services Supports XML and Binary Serialization
- Summary
- 11. Customizing Entities
- Partial Classes
- Using Partial Methods
- The OnContextCreated Method
- The On[Property]Changed and On[Property]Changing Methods
- Using PropertyChanged to Calculate Database-Computed Columns Locally
- Subscribing to Event Handlers
- The ObjectContext.ObjectMaterialized Event
- The ObjectContext.SavingChanges Event
- GetObjectStateEntries: A critical method when validating entities from the context
- Implementing SavingChanges
- Setting default foreign keys in SavingChanges when no foreign key scalar property exists
- The EntityObject.PropertyChanging and EntityObject.PropertyChanged Events
- The order of the Changing/Changed events
- Event parameters
- Subscribing to the class-level PropertyChanging and PropertyChanged events
- The AssociationChanged Event
- Event arguments
- Creating Your Own Partial Methods and Properties
- Overriding the Object Constructor
- Overriding ObjectContext.SaveChanges
- Creating Custom Properties
- Using custom properties to perform calculations on child collections
- Overloading Entity Creation Methods
- Using Partial Classes for More Than Just Overriding Methods and Events
- Overriding Default Code Generation
- Switching to a Template
- Reading the Template
- Modifying the Template
- Inserting the Managed partial method in each entity class
- Other ways to create common methods or properties for all entities
- Customizing a Template for Major Class Modifications
- Switching Between the Default Template and a Custom Template
- Summary
- 12. Data Binding with RAD ASP.NET Applications
- Using the EntityDataSource Control to Access Flat Data
- Creating the Hello Entities Project
- Creating a GridView and an EntityDataSource Concurrently
- Configuring an EntityDataSource with Its Wizard
- Formatting the GridView
- Testing the Web Application
- Understanding How the EntityDataSource Retrieves and Updates Your Data
- EntityDataSource and Its Query
- EntityDataSource and Its ObjectContext
- Using your own context
- EntityDataSource Context Events
- EntityDataSource and ViewState
- Accessing Foreign Keys When There Is No Foreign Key Property
- Working with Related EntityReference Data
- Using EntityDataSource.Include to Get Related Data
- Displaying Data That Comes from EntityReference Navigation Properties
- Using a New EntityDataSource Control to Enable Editing of EntityReference Navigation Properties
- Editing EntityReferences That Cannot Be Satisfied with a Drop-Down List
- Binding an EntityDataSource to Another Control with WhereParameters
- Editing Related Data Concurrently with Multiple EntityDataSource Controls
- Working with Hierarchical Data in a Master/Detail Form
- Setting Up the Web Application
- Specifying Your Own Entity SQL Query Expression for an EntityDataSource
- Binding a DropDownList to an EntityDataSource Control
- Creating a Parent EntityDataSource That Is Controlled by the DropDownList and Provides Data to a DetailsView
- Using the EntityDataSource.Where Property to Filter Query Results
- Displaying Read-Only Child Data Through the Parent EntityDataSource
- Using a New EntityDataSource to Add a Third Level of Hierarchical Data to the Master/Detail Form
- Using the EntityDataSource.Inserting Event to Help with Newly Added Entities
- Testing the Application
- Exploring EntityDataSource Events
- Building Dynamic Data Websites
- Summary
- Using the EntityDataSource Control to Access Flat Data
- 13. Creating and Using POCO Entities
- Creating POCO Classes
- Creating an ObjectContext Class to Manage the POCOs
- Verifying the POCOs with a query
- Creating an ObjectContext Class to Manage the POCOs
- Change Tracking with POCOs
- Understanding the Importance of DetectChanges
- Loading Related Data with POCOs
- Loading from the Context
- Lazy Loading from a Dynamic Proxy
- Exploring and Correcting POCOs Impact on Two-Way Relationships
- Using the DetectChanges Method to Fix Relationships
- Enabling Classes to Fix Their Own Relationships
- Using Proxies to Enable Change Notification, Lazy Loading, and Relationship Fix-Up
- Change Notification by Proxy
- Lazy Loading by Proxy
- Exploring the Proxy Classes
- Synchronizing Relationships by Proxy
- Using T4 to Generate POCO Classes
- Modifying the POCO Template
- Creating a Model That Works with Preexisting Classes
- Code First: Using Entity Framework with No Model at All
- Summary
- Creating POCO Classes
- 14. Customizing Entity Data Models Using the EDM Designer
- Mapping Table per Type Inheritance for Tables That Describe Derived Types
- Mapping TPT Inheritance
- Handling duplicate names and concurrency properties in an inheritance hierarchy
- Fixing a potential constraint problem
- Querying Inherited Types
- POCO Classes and Inherited Objects
- Inserting TPT Inherited Types
- SaveChanges and newly added derived types
- Specifying or Excluding Derived Types in Queries
- Creating New Derived Entities When the Base Entity Already Exists
- TPT with Abstract Types
- Mapping TPT Inheritance
- Mapping Unique Foreign Keys
- Mapping an Entity to More Than One Table
- Merging Multiple Entities into One
- Querying, Editing, and Saving a Split Entity
- Mapping Stored Procedures to Split Tables and More
- Splitting a Single Table into Multiple Entities
- Filtering Entities with Conditional Mapping
- Creating a Conditional Mapping for the Activity Entity
- Querying, Inserting, and Saving with Conditional Mappings
- Filtering on Other Types of Conditions
- Removing the Conditional Mapping from Activity and Re-creating the Category Property
- Implementing Table per Hierarchy Inheritance for Tables That Contain Multiple Types
- Creating the Resort Derived Type
- Setting a Default (Computed) Value on the Table Schema
- Testing the TPH Mapping
- Choosing to Turn a Base Class into an Abstract Class
- Creating Complex Types to Encapsulate Sets of Properties
- Defining a Complex Type
- Reusing Complex Types
- Querying, Creating, and Saving Entities That Contain Complex Types
- Removing the Complex Types from the Model
- Using Additional Customization Options
- Using GUIDs for EntityKeys
- Mapping Stored Procedures
- Mapping Multiple Entity Sets per Type
- Mapping Self-Referencing Associations
- Summary
- Mapping Table per Type Inheritance for Tables That Describe Derived Types
- 15. Defining EDM Mappings That Are Not Supported by the Designer
- Using Model-Defined Functions
- Using Model-Defined Functions to Return More Complex Results
- Consuming the Complex Results
- Reading the Results from a Complex Function
- Mapping Table per Concrete (TPC) Type Inheritance for Tables with Overlapping Fields
- Using QueryView to Create Read-Only Entities and Other Specialized Mappings
- Finding a Common Use Case for QueryView
- Creating a CustomerNameAndID Entity
- Creating a QueryView Mapping for CustomerNameAndID
- Testing the QueryView
- Deconstructing the QueryView
- Summary
- Using Model-Defined Functions
- 16. Gaining Additional Stored Procedure and View Support in the Raw XML
- Reviewing Procedures, Views, and UDFs in the EDM
- Working with Stored Procedures That Return Data
- Using Functions That Match an Entity Whose Property Names Have Been Changed
- Query Stored Procedures and Inherited Types
- Composing Queries Against Functions
- Replacing Stored Procedures with Views for Composability
- Queries That Return Multiple Result Sets
- Executing Queries on Demand with ExecuteStoreQuery
- Querying to a Class That Is Not an Entity
- Querying into an Entity
- Adding Native Queries to the Model
- Defining a Complex Type in the Model Browser
- Adding Native Views to the Model
- DefiningQuery Is Already in Your Model
- Using DefiningQuery to Create Your Own Views
- Implementing a DefiningQuery
- Creating Associations with the New Entity
- Testing the DefiningQuery in an association
- Using DefiningQuery to Solve More Complex Problems
- Using Commands That Affect the Database
- Executing SQL on the Fly with ExecuteStoreCommand
- Using Functions to Manipulate Data in the Database
- Changing from one derived type to another
- Mapping Insert/Update/Delete to Types Within an Inheritance Structure
- What If Stored Procedures Affect Multiple Entities in an Inheritance Structure?
- Implementing and Querying with User-Defined Functions (UDFs)
- Summary
- 17. Using EntityObjects in WCF Services
- Planning for an Entity FrameworkAgnostic Client
- Assessing the Pros and Cons of an Entity FrameworkAgnostic Consumer
- Building a Simple WCF Service with EntityObjects
- Creating the Service
- Defining the Service Operations
- Defining Extra Service Classes
- Exposing Custom Properties
- Implementing the Service Interface
- Adding Graphs to ObjectContext
- Deleting Objects
- Updating the Object Graph
- Client Rules for Identifying Changes in an EntityCollection
- The UpdateCustomer Method
- Handling New and Existing Reservations
- Deleting Reservations
- Building a Simple Console App to Consume an EntityObject Service
- Enabling the Client Application to Receive Large Messages from the Service
- Creating Methods to Test the Service Operations
- Analyzing the GetAndUpdateCustomer Method
- Testing Out the Other Service Operations
- Creating WCF Data Services with Entities
- Putting WCF Data Services in Perspective
- Creating a WCF Data Service
- Filtering at the Service Level Using QueryInterceptor
- Anticipating Exceptions
- Exposing Related Data Through the Service
- Preparing for WCF Data Services Limitations
- Modifying Data Through a Service
- Learning More About Creating and Consuming WCF Data Services
- Understanding How WCF RIA Services Relates to the Entity Framework
- Summary
- Planning for an Entity FrameworkAgnostic Client
- 18. Using POCOs and Self-Tracking Entities in WCF Services
- Creating WCF-Friendly POCO Classes
- Updating the POCO Classes Based on the Current BreakAway Model
- Isolating the POCO Entities in Their Own Project
- Directing a template back to a model
- Specifying the namespace of entity classes
- Providing the ObjectContext with a reference to the entities
- Adding Custom Logic to the POCO Entities with a Base Class
- Modifying the template to apply the inheritance
- Following WCF Collection Rules
- Preventing Properties from Being Marked As Virtual
- Building a WCF Service That Uses POCO Classes
- Implementing the Interface
- Using the Service
- Using the Self-Tracking Entities Template for WCF Services
- Creating and Exploring the Self-Tracking Entities
- Putting the Change-Tracking Logic Where Its Needed
- Creating a WCF Service That Uses Self-Tracking Entities
- Watching Self-Tracking Entities Under the Covers
- Debugging the client application
- Debugging the SaveCustomer service method
- Inspecting the Generated Context Class and Extensions
- Using POCO Entities with WCF Data and RIA Services
- Preparing for WCF Data Services
- Dealing with entities that live in a separate assembly
- Avoiding problems caused by dynamic proxies
- Using POCO Entities in WCF RIA Services
- Preparing for WCF Data Services
- Sorting Out the Many Options for Creating Services
- Summary
- Creating WCF-Friendly POCO Classes
- 19. Working with Relationships and Associations
- Deconstructing Relationships in the Entity Data Model
- Understanding How the Entity Data Model Wizard Creates the Association
- Understanding Additional Relationship Items
- Handling Nonessential Navigation Properties
- Understanding the Major Differences Between Foreign Key Associations and Independent Associations
- Defining Associations in Metadata
- Detecting Associations at Runtime
- Deconstructing Relationships Between Instantiated Entities
- Understanding Relationship Manager and the IRelatedEnd Interface
- Late-Binding Relationships
- Taking a Peek Under the Covers: How Entity Framework Manages Relationships
- Understanding Navigation Properties
- EntityReference properties
- EntityReference.Value
- What if there is no EntityReference
- EntityCollection properties
- EntityReference properties
- Understanding Referential Integrity and Constraints
- Constraints that are not checked until they hit the database
- Checking for missing entity references with and without foreign keys
- Implementing Deletes and Cascading Deletes
- Cascading deletes in the database
- Recommendation: Cascade in both the model and the database, or in neither
- Defining Relationships Between Entities
- The CLR Way: Setting a Navigation Property to an Entity
- Setting a Foreign Key Property
- Setting an EntityReference Using an EntityKey
- Loading, Adding, and Attaching Navigation Properties
- Lazy Loading
- EntityReference.Load and EntityCollection.Load
- Loading from Detached Entities: Lazy and Explicit
- Using EntityCollection.Add
- Adding new entities that are detached
- Adding existing entities that are detached
- Adding new or existing entities that are attached
- Adding entities to the EntityCollection of a detached object
- Using Attach and Remove
- Moving an Entity to a New Graph
- Learning a Few Last Tricks to Make You a Relationship Pro
- Using CreateSourceQuery to Enhance Deferred Loading
- Getting a Foreign Key Value in an Independent Association
- Summary
- Deconstructing Relationships in the Entity Data Model
- 20. Real World Apps: Connections, Transactions, Performance, and More
- Entity Framework and Connections
- Overriding EntityConnection Defaults
- Working with Connection Strings Programmatically
- Constructing connection strings on the fly with the EntityConnectionStringBuilder class
- Choosing and loading a model programmatically
- Constructing connection strings on the fly with the EntityConnectionStringBuilder class
- Opening and Closing Connections
- Understanding the default connection usage
- Default behavior 1: Many calls on a single connection
- Default behavior 2: Multiple connections
- Forcing an explicit connection
- Understanding the default connection usage
- Getting the Store Connection from EntityConnection
- Disposing Connections
- Pooling Connections
- Fine-Tuning Transactions
- Why Use Your Own Transaction?
- Understanding Implicit Entity Framework Transactions
- Understanding SaveOptions and AcceptAllChanges in a transaction
- Specifying Your Own Read/Write Transactions
- Specifying Your Own Read-Only Transactions
- Rolling Back Transactions
- Understanding Security
- Guarding Against SQL Injection
- Taking precautions with dynamic queries
- Entity SQL injection
- Guarding Against Connection Piggybacks
- Guarding Against SQL Injection
- Fine-Tuning Performance
- Measuring Query Performance
- Measuring Startup Performance
- Reducing the Cost of Query Compilation
- Caching for Entity SQL Queries
- Comparing EntityClient to Object Services
- Precompiling Views for Performance
- Pregenerating views for performance
- Pregenerating views into an existing project
- Precompiling LINQ to Entities Queries for Performance
- Fine-Tuning Updates for Performance?
- Lacking Support for Full Text Searches
- Exploiting Multithreaded Applications
- Forcing an ObjectContext to Use Its Own Thread
- Implementing Concurrent Thread Processing
- Exploiting .NET 4 Parallel Computing
- Summary
- Entity Framework and Connections
- 21. Manipulating Entities with ObjectStateManager and MetadataWorkspace
- Manipulating Entities and Their State with ObjectStateManager
- Refreshing Your High-Level Understanding of ObjectStateEntry
- Getting an ObjectStateManager and Its Entries
- Getting groups of entries with GetObjectStateEntries
- Building Extension Methods to Overload GetObjectStateEntries
- Building a Method to Return Managed Entities
- Using GetObjectStateEntry and TryGetObjectStateEntry
- Mining Entity Details from ObjectStateEntry
- Reading and writing values
- Accessing object metadata with CurrentValueRecord.DataRecordInfo
- Getting started with the FieldMetadata hierarchy
- Leveraging the ObjectStateManager During Saves
- Using ObjectStateManager to Build an EntityState Visualizer
- Retrieving an ObjectStateEntry Using an EntityKey
- Reading the OriginalValues and CurrentValues of an ObjectStateEntry
- Determining Whether a Property Has Been Modified
- Displaying the State and Entity Type
- Getting ComplexType Properties Out of ObjectStateEntry
- Modifying Values with ObjectStateManager
- Working with Relationships in ObjectStateManager
- Building graphs directly with the RelationshipManager
- Using the MetadataWorkspace
- Loading the MetadataWorkspace
- Creating a MetadataWorkspace without an EntityConnection
- Clearing the MetadataWorkspace from Memory
- Understanding the MetadataWorkspace ItemCollections
- Determining whether an ItemCollection has been loaded
- Retrieving Metadata from the MetadataWorkspace
- Retrieving sets of items from the metadata with GetItems and TryGetItem
- Retrieving specific items from the metadata with GetItem and TryGetItem
- Retrieving functions from the metadata with GetFunctions and TryGetFunctions
- Querying the Metadata with LINQ to Objects
- Loading the MetadataWorkspace
- Building Dynamic Queries and Reading Results
- Building Entity SQL Queries Dynamically Using Metadata
- Creating Queries on the Fly with CreateObjectSet and Query Builder Methods
- Leveraging CreateObjectSet to return Entity SQL, not just a query
- Reading the Results of a Dynamically Created Query
- Creating and Manipulating Entities Dynamically
- Creating EntityObjects Without Entity Classes
- Creating a new entity with CreateInstance
- Getting a reference to an assembly
- Creating an entity from the assembly
- Using System.Type to inspect the EntityType
- Creating a new entity with CreateInstance
- Creating Entities and Graphs Dynamically
- Custom extension methods used by AddChildToParentObject
- Calling the AddChildToParentObject method
- Creating EntityObjects Without Entity Classes
- Summary
- Manipulating Entities and Their State with ObjectStateManager
- 22. Handling Exceptions
- Preparing for Exceptions
- Handling EntityConnectionString Exceptions
- Connection String Cant Be Found or Is Improperly Configured: System.ArgumentException
- Metadata Files Cannot Be Found: System.Data.MetadataException
- Handling Connection String Exceptions
- Handling Query Compilation Exceptions
- Invalid LINQ to Entities Query Expressions: System.NotSupportedException
- Invalid Entity SQL Query Expressions: EntitySqlException
- Handling an EntitySqlException
- EntityCommandCompilationException Thrown by the Store Provider
- Creating a Common Wrapper to Handle Query Execution Exceptions
- Handling Exceptions Thrown During SaveChanges Command Execution
- UpdateException: Thrown When Independent Association Mapping Constraints Are Broken
- UpdateException: Thrown by Broken Constraints in the Database
- Relying on Entity Framework to Automatically Roll Back When an UpdateException Occurs
- Gleaning Details from UpdateException
- Planning for Other Exceptions Related to the Entity Framework
- Handling Concurrency Exceptions
- Summary
- 23. Planning for Concurrency Problems
- Understanding Database Concurrency Conflicts
- Understanding Optimistic Concurrency Options in the Entity Framework
- Ignoring Concurrency Conflicts
- Forcing the Users Data to the Server (ClientWins)
- Refreshing the Users Data with Server Data (StoreWins)
- Determining the Scope of Changes
- Using rowversion (a.k.a. timestamp) for Concurrency Checks
- Implementing Optimistic Concurrency with the Entity Framework
- Flagging a Property for Concurrency Checking
- How the Entity Framework Uses the ConcurrencyMode Property
- Concurrency Checking Without a rowversion Field
- Concurrency Checking on a Checksum in the Data Store
- Concurrency Checks for EntityReference Navigation Properties
- Concurrency Checks and Inherited Types
- Concurrency Checks and Stored Procedures
- Defining a stored procedure to perform concurrency checking
- Handling OptimisticConcurrencyExceptions
- Using ObjectContext.Refresh
- Using Refresh with ClientWins
- Using Refresh with StoreWins
- Refreshing Collections of Entities
- Refreshing Related Entities in a Graph
- Rewinding and Starting Again, and Maybe Again After That
- Reporting an Exception
- Handling Concurrency Exceptions at a Lower Level
- Handling Exceptions in a Granular Way Without User Intervention
- Handling Multiple Conflicts
- Separating the good from the bad and the ugly
- Handling Exceptions When Transactions Are Your Own
- Summary
- 24. Building Persistent Ignorant, Testable Applications
- Testing the BreakAway Application Components
- Getting Started with Testing
- Writing an Integration Test That Hits the Database
- Inspecting a Failed Test
- Writing a Unit Test That Focuses on Custom Logic
- Creating Persistent Ignorant Entities
- Planning the Project Structure
- Starting with the Model and Its POCO Entities
- Building an Interface to Represent a Context
- Modifying the BAEntities ObjectContext Class to Implement the New Interface
- Disconnecting the context class from the T4 template
- Implementing the IContext interface
- Implementing the remaining interface members
- Creating the IEntityRepository Interface
- Creating the Repository Classes
- Testing GetReservationsForCustomer Against the Database
- Creating a Fake Context
- Creating a FakeObjectSet Class
- Completing the Fake Context
- Modify the tests to use the fake repository
- Rerun the tests
- Building Tests That Do Not Hit the Database
- Adding Validation Logic to the POCO Class
- Adding Validation Logic to the Context
- Providing ManagedEntities in the FakeContext
- Hiding the Context from the Lower Layers with Unit of Work
- Testing UnitOfWork Against the Database
- Enabling Eager Loading in IContext
- Eager loading with a fake context
- Leveraging Precompiled Queries in Your Repositories
- Using the New Infrastructure in Your Application
- Adding a UI Layer That Calls the Repository
- Application Architecture Benefits from Designing Testable Code
- Considering Mocking Frameworks?
- Summary
- 25. Domain-Centric Modeling
- Creating a Model and Database Using Model First
- Creating a Conceptual Model in the Designer
- Creating the Entities
- Setting attributes of the entitys properties
- Creating Association and Inheritance Hierarchies
- Creating a one-to-many relationship
- Creating a many-to-many relationship
- Creating an inheritance hierarchy
- Generating Database Schema from the Model
- Exploring the generated DDL
- Looking at the result of the inheritance
- Noting the result of the many-to-many relationship
- Exploring the constraints
- Completing the generation of the DDL
- Creating the Database and Its Schema
- Overriding the DDL Generation
- Using the Feature CTP Code-First Add-On
- Understanding Code-First Design
- Installing the Feature CTP
- Exploring Some Configuration Examples
- Testing the Code-First Application and Database
- Using SQL Server Modelings M Language
- Using M Metadata in Entity Framework Applications
- Summary
- Creating a Model and Database Using Model First
- 26. Using Entities in Layered Client-Side Applications
- Isolating the ObjectContext
- Freeing Entities from Change Tracking
- Enabling Change Tracking Across Tiers
- Moving Other ObjectContext-Dependent Logic to the DataBridge
- Ensuring That Lazy Loading Doesnt Negatively Impact the Layered Application
- Noting Additional Benefits of the Layered Application
- Separating Entity-Specific Logic from ObjectContext Logic
- Working with POCO Entities
- Providing EntityState
- Providing Logic in Place of Other EntityObject Behavior
- Summary
- Isolating the ObjectContext
- 27. Building Layered Web Applications
- Understanding How ObjectContext Fits into the Web Page Life Cycle
- Return Results, Not Queries, from the DataBridge Class
- Using Entities in Read-Only Web Pages
- Exploring Options for Updating Entities in an ASP.NET Web Forms Application
- Single or batch updates?
- Persist entities or use independent values?
- Comparing ASP.NETs State Solutions to the Needs of the Entity Framework
- View state
- Application cache and session state
- Building an N-Tier Web Forms Application
- Designing the Application
- Using the Existing Repositories
- Building an Entity Manager to Act As a DataBridge
- Retrieving Data for Display and for Future Updates
- Making the Related Data Accessible to the Client
- Getting Data from the Manager to the Client
- Adding Lists for User Selection Controls
- Allowing a User to Modify Related Data
- Building an ASP.NET MVC Application
- Replacing the Context with Repositories
- Editing Entities and Graphs on an MVC Application
- Creating a Repository for Payments
- Interacting with the ReservationController
- Summary
- Understanding How ObjectContext Fits into the Web Page Life Cycle
- A. Entity Framework Assemblies and Namespaces
- Unpacking the Entity Framework Files
- Exploring the Namespaces
- Existing Namespaces That Include Entity Framework Classes and Functionality
- Entity Framework-Specific Namespaces
- B. Data-Binding with Complex Types
- Using Complex Types with ASP.NET EntityDataSource
- Identifying Unexpected Behavior When Binding Complex Types
- Successfully Using Binding to Complex Types in ASP.NET Without Data Source Controls
- List controls
- Data-bound controls
- Templated controls
- Windows Forms DataSource and Complex Types
- Successfully Using Binding to Complex Types in ASP.NET Without Data Source Controls
- C. Additional Details About Entity Data Model Metadata
- Seeing EDMX Schema Validation in Action
- Additional Conceptual Model Details
- Schema
- XML Representation of an Association
- AssociationSet
- Additional SSDL Metadata Details
- SSDL Association and AssociationSet Elements
- ReferentialConstraint
- SSDL Association and AssociationSet Elements
- Additional MSL Metadata Details
- The MSL Elements
- Mapping
- EntityContainerMapping
- EntitySetMapping
- EntityTypeMapping
- MappingFragment
- ScalarProperty
- AssociationSetMapping
- The MSL Elements
- Index
- About the Author
- Colophon
- SPECIAL OFFER: Upgrade this ebook with OReilly
O'Reilly Media - inne książki
-
Nowość Promocja Promocja 2za1
Business decisions in any context—operational, tactical, or strategic—can have considerable consequences. Whether the outcome is positive and rewarding or negative and damaging to the business, its employees, and stakeholders is unknown when action is approved. These decisions are usually made under the proverbial cloud of uncertainty.With this pra- ePub + Mobi pkt
(177,65 zł najniższa cena z 30 dni)
186.15 zł
219.00 zł (-15%) -
Nowość Promocja Promocja 2za1
If you're a developer looking to build a distributed, resilient, scalable, high-performance application, you may be evaluating distributed SQL and NoSQL solutions. Perhaps you're considering the Aerospike database.This practical book shows developers, architects, and engineers how to get the highly scalable and extremely low-latency Aerospike datab- ePub + Mobi pkt
Aerospike: Up and Running. Developing on a Modern Operational Database for Globally Distributed Apps
(228,65 zł najniższa cena z 30 dni)
245.65 zł
289.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Learn how to use Go's strengths to develop services that are scalable and resilient even in an unpredictable environment. With this book's expanded second edition, Go developers will explore the composition and construction of cloud native applications, from lower-level Go features and mid-level patterns to high-level architectural considerations.E- ePub + Mobi pkt
(203,15 zł najniższa cena z 30 dni)
220.15 zł
259.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Reinforcement learning (RL) has led to several breakthroughs in AI. The use of the Q-learning (DQL) algorithm alone has helped people develop agents that play arcade games and board games at a superhuman level. More recently, RL, DQL, and similar methods have gained popularity in publications related to financial research.This book is among the fir- ePub + Mobi pkt
(203,15 zł najniższa cena z 30 dni)
220.15 zł
259.00 zł (-15%) -
Nowość Promocja Promocja 2za1
To ensure that applications are reliable and always available, more businesses today are moving applications to AWS. But many companies still struggle to design and build these cloud applications effectively, thinking that because the cloud is resilient, their applications will be too. With this practical guide, software, DevOps, and cloud engineer- ePub + Mobi pkt
(203,15 zł najniższa cena z 30 dni)
220.15 zł
259.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Performance tuning is an experimental science, but that doesn't mean engineers should resort to guesswork and folklore to get the job done. Yet that's often the case. With this practical book, intermediate to advanced Java technologists working with complex platforms will learn how to tune Java cloud applications for performance using a quantitativ- ePub + Mobi pkt
(203,15 zł najniższa cena z 30 dni)
220.15 zł
259.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Today, investment in financial technology and digital transformation is reshaping the financial landscape and generating many opportunities. Too often, however, engineers and professionals in financial institutions lack a practical and comprehensive understanding of the concepts, problems, techniques, and technologies necessary to build a modern, r- ePub + Mobi pkt
(203,15 zł najniższa cena z 30 dni)
220.15 zł
259.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Until recently, infrastructure was the backbone of organizations operating software they developed in-house. But now that cloud vendors run the computers, companies can finally bring the benefits of agile custom-centricity to their own developers. Adding product management to infrastructure organizations is now all the rage.But how's that possible- ePub + Mobi pkt
(177,65 zł najniższa cena z 30 dni)
186.15 zł
219.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Cloud services and SaaS software permeate every company's IT landscape, requiring a shift from manually provisioned services to a more structured approach, with codification at its core. Terraform provides tools to manage the lifecycle of your IT landscape across thousands of different cloud providers and SaaS platforms.By defining your infrastruct- ePub + Mobi pkt
(194,65 zł najniższa cena z 30 dni)
211.65 zł
249.00 zł (-15%) -
Nowość Promocja Promocja 2za1
Using machine learning for products, services, and critical business processes is quite different from using ML in an academic or research setting—especially for recent ML graduates and those moving from research to a commercial environment. Whether you currently work to create products and services that use ML, or would like to in the future, this- ePub + Mobi pkt
(228,65 zł najniższa cena z 30 dni)
245.65 zł
289.00 zł (-15%)
Dzięki opcji "Druk na żądanie" do sprzedaży wracają tytuły Grupy Helion, które cieszyły sie dużym zainteresowaniem, a których nakład został wyprzedany.
Dla naszych Czytelników wydrukowaliśmy dodatkową pulę egzemplarzy w technice druku cyfrowego.
Co powinieneś wiedzieć o usłudze "Druk na żądanie":
- usługa obejmuje tylko widoczną poniżej listę tytułów, którą na bieżąco aktualizujemy;
- cena książki może być wyższa od początkowej ceny detalicznej, co jest spowodowane kosztami druku cyfrowego (wyższymi niż koszty tradycyjnego druku offsetowego). Obowiązująca cena jest zawsze podawana na stronie WWW książki;
- zawartość książki wraz z dodatkami (płyta CD, DVD) odpowiada jej pierwotnemu wydaniu i jest w pełni komplementarna;
- usługa nie obejmuje książek w kolorze.
Masz pytanie o konkretny tytuł? Napisz do nas: sklep@helion.pl
Książka drukowana
Oceny i opinie klientów: Programming Entity Framework. Building Data Centric Apps with the ADO.NET Entity Framework. 2nd Edition Julia Lerman (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.