Muutke küpsiste eelistusi

Designing and Developing Enterprise Applications Using the Microsoft® .NET Framework: MCPD Self-Paced Training Kit (Exam 70-549) [Multiple-component retail product]

4.11/5 (18 hinnangut Goodreads-ist)
,
  • Formaat: Multiple-component retail product, 560 pages, kõrgus x laius: 235x187 mm, Contains 1 Paperback / softback and 1 CD-ROM
  • Ilmumisaeg: 28-Mar-2007
  • Kirjastus: Microsoft Press,U.S.
  • ISBN-10: 0735623384
  • ISBN-13: 9780735623385
Teised raamatud teemal:
  • Multiple-component retail product
  • Hind: 68,23 €*
  • * saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
  • See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
  • Kogus:
  • Lisa ostukorvi
  • Tasuta tarne
  • Lisa soovinimekirja
Designing and Developing Enterprise Applications Using the Microsoft® .NET Framework: MCPD Self-Paced Training Kit (Exam 70-549)Suurem pilt
  • Formaat: Multiple-component retail product, 560 pages, kõrgus x laius: 235x187 mm, Contains 1 Paperback / softback and 1 CD-ROM
  • Ilmumisaeg: 28-Mar-2007
  • Kirjastus: Microsoft Press,U.S.
  • ISBN-10: 0735623384
  • ISBN-13: 9780735623385
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9780735623385.html
Märksõnad:
This book/CD-ROM kit will help readers prepare for the MCPD Exam 70-549. Within each chapter, material is broken down into short lessons with lesson summaries and review. Other learning features include chapter reviews, case scenarios, key terms, and lab exercises. In addition to code samples and evaluation versions of software, the accompanying CD-ROM contains practice tests with a total of hundreds of questions using multiple testing modes to meet readers' specific learning needs. After completing a test on the CD-ROM, readers receive detailed explanations for right and wrong answers, and a customized learning path that describes how and where to focus their studies. It is assumed that readers are familiar with creating enterprise applications using Microsoft Visual Studio 2000 and ASP.NET 2.0, and that they have a working knowledge of Microsoft Visual Basic or C#. Johnson is a 25-year veteran of the computer industry. Lanham is a Windows and Web application developer. Annotation ©2007 Book News, Inc., Portland, OR (booknews.com)

EXAM PREP GUIDE

Ace your preparation for the skills measured by MCPD Exam 70-549—and on the job. Work at your own pace through a series of lessons and reviews that fully cover each exam objective. Then, reinforce what you’ve learned by applying your knowledge to real-world case scenarios and labs. This official Microsoft study guide is designed to help you make the most of your study time.

Maximize your performance on the exam by learning to:

  • Evaluate the logical and physical design of an application model
  • Design and develop components to implement business logic and data access
  • Identify the appropriate mechanism to deliver multimedia in distributed applications
  • Choose a data structure, state management technique, and security implementation strategy
  • Determine appropriate event-logging and monitoring methods
  • Define and evaluate a testing strategy and deployment plan

PRACTICE TESTS

Assess your skills with practice tests on CD. You can work through hundreds of questions using multiple testing modes to meet your specific learning needs. You get detailed explanations for right and wrong answers—including a customized learning path that describes how and where to focus your studies.

Your kit includes:

  • 15% exam discount from Microsoft. Offer expires 12/31/11. Details inside.
  • Official self-paced study guide.
  • Practice tests with multiple, customizable testing options and a learning plan based on your results.
  • 275+ practice and review questions.
  • Case scenarios and lab exercises.
  • Microsoft Visual Basic and Visual C# code samples on CD.
  • 90-day evaluation version of Microsoft Visual Studio 2005 Professional Edition.
  • Fully searchable eBook of this guide.

A Note Regarding the CD or DVD

The print version of this book ships with a CD or DVD. For those customers purchasing one of the digital formats in which this book is available, we are pleased to offer the CD/DVD content as a free download via O'Reilly Media's Digital Distribution services. To download this content, please visit O'Reilly's web site, search for the title of this book to find its catalog page, and click on the link below the cover image (Examples, Companion Content, or Practice Files). Note that while we provide as much of the media content as we are able via free download, we are sometimes limited by licensing restrictions. Please direct any questions or concerns to booktech@oreilly.com.

Introduction xxi
Hardware Requirements xxi
Software Requirements xxi
Using the CD and DVD xxiii
How to Install the Practice Tests xxiii
How to Use the Practice Tests xxiii
How to Uninstall the Practice Tests xxv
Microsoft Certified Professional Program xxv
Technical Support xxv
Evaluation Edition Software Support xxvi
Evaluating the Technical Feasibility of an Application
1(38)
Before You Begin
2(1)
Lesson 1: Evaluating Requirements and Proposing a Design
3(19)
What Makes a Good Set of Application Requirements?
4(3)
Evaluating the Requirements for the Application
7(1)
Recommending Best Technologies
8(7)
Investigating Existing Solutions for Similar Business Problems
15(1)
Creating a High-Level Application Design
16(2)
Lab: Evaluating Requirements and Recommending Technology
18(1)
Lesson Summary
19(1)
Lesson Review
20(2)
Lesson 2: Creating a Proof-of-Concept Prototype to Refine an Application's Design
22(11)
What Constitutes a Good Prototype?
23(1)
Mockups and Proof-of-Concept Prototypes
23(1)
Creating a Prototype to Evaluate Key Design Decisions
24(5)
Demonstrating the Feasibility of the Design
29(1)
Lab: Creating a Proof-of-Concept Prototype
30(1)
Lesson Summary
31(1)
Lesson Review
31(2)
Chapter Review
33(1)
Chapter Summary
33(1)
Key Terms
34(1)
Case Scenario
34(2)
Case Scenario: Evaluate Requirements and Propose an Application Design
34(2)
Suggested Practices
36(1)
Evaluating Requirements and Proposing a Design
36(1)
Creating a Proof-of-Concept Prototype to Refine an Application's Design
37(1)
Take a Practice Test
37(2)
Creating Specifications for Developers
39(46)
Before You Begin
39(2)
Lesson 1: Create a Logical Model
41(12)
Object Role Modeling
41(1)
The ORM Notation
42(5)
Driving ORM Diagrams from Requirements and Use Cases
47(1)
Using ORM Diagrams to Identify Objects, Properties, Methods, Entities, and Fields
48(1)
Lab: Create a Logical Model
49(1)
Lesson Summary
50(1)
Lesson Review
51(2)
Lesson 2: Define Application Layers
53(8)
Define the Layers of Your Application
53(4)
Define Communication Between Layers
57(1)
Lab: Define Logical Application Layers
58(1)
Lesson Summary
59(1)
Lesson Review
59(2)
Lesson 3: Create Physical Models for Developers
61(18)
Create a Component Diagram
62(2)
Create a Class Diagram
64(3)
Create a Sequence Diagram
67(2)
Create an Activity Diagram
69(1)
Create an Entity-Relationship Diagram
70(3)
Create Pseudocode
73(1)
Lab: Create Physical Models
73(4)
Lesson Summary
77(1)
Lesson Review
77(2)
Chapter Review
79(1)
Chapter Summary
79(1)
Key Terms
80(1)
Case Scenario
80(2)
Case Scenario: Evaluate User Inputs and Create Physical Models
80(2)
Suggested Practices
82(1)
Define Objects and their Relationships (Create a Logical Model)
82(1)
Create a Logical Architecture
83(1)
Create Physical Models for Developers
83(1)
Take a Practice Test
83(2)
Design Evaluation
85(16)
Before You Begin
86(1)
Lesson 1: Evaluating the Logical Design
87(6)
Evaluation of the Logical Design
87(5)
Lesson Summary
92(1)
Lesson Review
92(1)
Lesson 2: Evaluating the Physical Design
93(5)
Evaluation of the Physical Design
93(3)
Lesson Summary
96(1)
Lesson Review
96(2)
Chapter Review
98(1)
Chapter Summary
98(1)
Key Terms
98(1)
Case Scenarios
98(1)
Case Scenario 1: Review the Logical Design of an Enterprise Application
98(1)
Case Scenario 2: Review the Physical Design of an Enterprise Application
99(1)
Suggested Practices
99(1)
Evaluate an Existing Logical Design
99(1)
Evaluate an Existing Physical Design
100(1)
Take a Practice Test
100(1)
Component Design
101(42)
Before You Begin
102(1)
Lesson 1: Database Design
103(17)
Database Design Basics
103(1)
Data Entities
104(2)
Primary Keys
106(3)
Entity Relationships
109(2)
Entity Attributes
111(4)
Recommend a Data Schema
115(2)
Lab: Defining Entity Relationships
117(1)
Lesson Summary
118(1)
Lesson Review
118(2)
Lesson 2: Designing a Component
120(13)
Component Characteristics
120(3)
High-Level Design
123(7)
Lab: Design a Database Logging Component
130(1)
Lesson Summary
131(1)
Lesson Review
131(2)
Lesson 3: Component Features
133(6)
Component Interfaces
133(4)
Lab: Determine Component Features
137(1)
Lesson Summary
138(1)
Lesson Review
138(1)
Chapter Review
139(1)
Chapter Summary
139(1)
Key Terms
139(1)
Case Scenarios
140(1)
Case Scenario 1: Design an Employee Component
140(1)
Case Scenario 2: Design a Database for the Company Library
140(1)
Suggested Practices
141(1)
Create a Database Schema
141(1)
Design Components
141(1)
Take a Practice Test
142(1)
Component Development
143(32)
Before You Begin
144(1)
Lesson 1: Implementing Component Features
145(11)
Extend, Compose, or Implement?
145(1)
Building Class Hierarchies
146(1)
Component State
147(1)
Multithreading
148(1)
Handling Unmanaged Resources
149(1)
Lab: Add Handling of Unmanaged Resources
150(4)
Lesson Summary
154(1)
Lesson Review
154(2)
Lesson 2: Data Access in Components
156(8)
Data Access
156(5)
Business Logic
161(1)
Lab: Choosing a Data Access Methodology
161(1)
Lesson Summary
162(1)
Lesson Review
162(2)
Lesson 3: Component Infrastructure
164(8)
Exceptions
164(3)
Profiling Components
167(1)
Lab: Propagating an Exception with Context
168(2)
Lesson Summary
170(1)
Lesson Review
170(2)
Chapter Review
172(1)
Chapter Summary
172(1)
Key Terms
172(1)
Case Scenarios
172(1)
Case Scenario 1: Choose a Data Access Methodology
173(1)
Case Scenario 2: Search for Resource Leaks
173(1)
Suggested Practices
173(1)
Consume an Unmanaged Resource
174(1)
Create a Data Access Component
174(1)
Take a Practice Test
174(1)
Multimedia in Distributed Applications
175(26)
Before You Begin
175(1)
Lesson 1: How to Choose a Delivery Mechanism
176(17)
What Are the Choices?
176(6)
Which Standard to Use?
182(5)
Lab: Using MTOM to Deliver Multimedia
187(4)
Lesson Summary
191(1)
Lesson Review
191(2)
Lesson 2: Challenges in Multimedia Delivery
193(5)
Bandwidth Restrictions
193(1)
Client Requirements
194(1)
Audio and Video Options
195(1)
Digital Rights Management
196(1)
Lesson Summary
196(1)
Lesson Review
197(1)
Chapter Review
198(1)
Chapter Summary
198(1)
Key Terms
198(1)
Case Scenarios
199(1)
Suggested Practices
199(1)
Create a Web Service That Delivers Dynamic Graphics
200(1)
Take a Practice Test
200(1)
Reusable Software Components
201(34)
Before You Begin
202(1)
Lesson 1: Consuming Reusable Software Components
203(28)
Identifying Reusable Components
203(2)
Extending and Restricting Reusable Components
205(15)
Lab: Consume a Reusable Software Component
220(7)
Lesson Summary
227(1)
Lesson Review
228(3)
Chapter Review
231(1)
Chapter Summary
231(1)
Key Terms
231(1)
Case Scenarios
232(1)
Case Scenario 1: Extending a Reusable Component
232(1)
Case Scenario 2: Restricting a Reusable Component
232(1)
Case Scenario 3: Restricting a Reusable Component
232(1)
Suggested Practices
233(1)
Consume a Reusable Software Component
233(1)
Take a Practice Test
234(1)
Design Logic Implementation
235(38)
Before You Begin
236(1)
Lesson 1: Implementation Approach Philosophies
237(3)
Waterfall Approach
237(1)
Agile Development
238(1)
Lesson Summary
239(1)
Lesson Review
239(1)
Lesson 2: Program Flow Control
240(1)
Organizing Code
240(6)
Creating the Blueprint
240(1)
Decision Flow
240(4)
Lab: Designing Application Flow Control
244(1)
Lesson Summary
245(1)
Lesson Review
245(1)
Lesson 3: Data Structure Designs
246(11)
Choosing a Data Storage Mechanism
246(5)
Designing the Data Flow
251(4)
Lesson Summary
255(1)
Lesson Review
255(2)
Lesson 4: State Management Design
257(4)
Stateful
257(1)
Stateless
258(1)
Web Services
259(1)
.NET Remoting
259(1)
Lesson Summary
259(1)
Lesson Review
259(2)
Lesson 5: Components versus Services
261(3)
Loose Coupling
261(1)
Performance
262(1)
Platform Independence
262(1)
Lesson Summary
263(1)
Lesson Review
263(1)
Lesson 6: Security Implementation
264(5)
Authentication
264(1)
Authorization
264(4)
Lesson Summary
268(1)
Lesson Review
268(1)
Chapter Review
269(1)
Chapter Summary
269(1)
Key Terms
269(1)
Case Scenarios
270(1)
Case Scenario 1: Scaling Out
270(1)
Case Scenario 2: Services
270(1)
Suggested Practices
271(1)
Designing Application Logic
271(1)
Take a Practice Test
271(2)
Logging and Monitoring
273(37)
Before You Begin
274(1)
Lesson 1: Logging in Distributed Applications
275(16)
Who Needs Logging?
275(1)
What Data Is Required?
276(5)
Data Storage Choices
281(5)
System-Wide Logging
286(1)
Lab: Common Logging Issues
287(2)
Lesson Summary
289(1)
Lesson Review
290(1)
Lesson 2: Monitoring Distributed Applications
291(15)
Who Needs Monitoring?
291(1)
Data Storage
292(5)
System-Wide Monitoring
297(3)
Lab: Monitoring Applications
300(5)
Lesson Summary
305(1)
Lesson Review
305(1)
Chapter Review
306(1)
Chapter Summary
306(1)
Key Terms
306(1)
Case Scenarios
307(1)
Case Scenario 1: Instrumenting a Distributed Application
307(1)
Suggested Practice
307(1)
Logging Application Events
307(1)
Monitoring the Application
308(1)
Take a Practice Test
308(2)
Planning for Testing
310(40)
Before You Begin
310(2)
Lesson 1: Creating a Unit Test Framework
312(13)
What Makes a Good Framework?
312(3)
The Properties of a Good Unit Test
315(2)
What Should Be Tested?
317(3)
Lab: Creating Unit Tests
320(3)
Lesson Summary
323(1)
Lesson Review
324(1)
Lesson 2: System-Level Testing
325(14)
Integration Testing
325(3)
Performance Testing
328(4)
Stress Testing
332(2)
Lab: System-Level Testing
334(3)
Lesson Summary
337(1)
Lesson Review
337(2)
Lesson 3: The Testing Environment
339(7)
Hardware Environment
339(1)
Software Environment
340(1)
Data
340(1)
Random Generation Techniques
341(3)
Lesson Summary
344(1)
Lesson Review
344(2)
Chapter Review
346(1)
Chapter Summary
346(1)
Key Terms
346(1)
Case Scenarios
347(1)
Case Scenario 1: Choosing the Tests
347(1)
Case Scenario 2: Choosing the Tests
347(1)
Suggested Practices
347(1)
Evaluate the Testing Strategy
347(1)
Take a Practice Test
348(2)
Unit Testing: The First Line of Defense
350(33)
Before You Begin
350(2)
Lesson 1: Identifying Testing Scenarios
352(13)
Anatomy of a Unit Test Suite
352(2)
What to Test
354(2)
Test Scenarios and Use Cases
356(4)
Lab: Identifying Test Scenarios
360(3)
Lesson Summary
363(1)
Lesson Review
363(2)
Lesson 2: Testing the Component Thoroughly
365(14)
Code Coverage
365(2)
Black-Box Testing
367(4)
Isolating Components
371(3)
Lab: Testing with Mock Objects
374(3)
Lesson Summary
377(1)
Lesson Review
377(2)
Chapter Review
379(1)
Chapter Summary
379(1)
Key Terms
379(1)
Case Scenarios
380(1)
Suggested Practices
380(1)
Take a Practice Test
381(2)
Stabilizing the Application
383(26)
Before You Begin
383(2)
Lesson 1: The Code Review Process
385(11)
Why Review Code?
385(4)
Code Review Excuses
389(1)
What Should a Review Look For?
390(4)
Lesson Summary
394(1)
Lesson Review
394(2)
Lesson 2: Integration Testing
396(10)
Integration Testing Defined
396(1)
Steps in Integration Testing
397(2)
Component Dependencies
399(2)
Lab: Identifying Dependent Assemblies
401(3)
Lesson Summary
404(1)
Lesson Review
404(2)
Chapter Review
406(1)
Chapter Summary
406(1)
Key Terms
406(1)
Case Scenarios
407(1)
Case Scenario 1: Determine the Code Review Requirements
407(1)
Case Scenario 2: Integration Testing for a Web Application
407(1)
Suggested Practices
408(1)
Perform a Code Review
408(1)
Perform Integration Testing
408(1)
Take a Practice Test
408(1)
Evaluating Application Performance
409(56)
Before You Begin
410(1)
Lesson 1: Evaluating Application Performance
411(7)
Why Track Application Performance?
411(4)
Lab 1: Documenting Application Performance Metrics
415(1)
Lesson Summary
416(1)
Lesson Review
416(2)
Lesson 2: Analyzing Monitoring Data
418(25)
Monitoring Resource Use
418(12)
Monitoring Security
430(6)
Lab 2: Monitoring and Instrumentation
436(5)
Lesson Summary
441(1)
Lesson Review
441(2)
Lesson 3: Evaluating the Deployment Plan
443(10)
What Is a Deployment Plan?
443(3)
Identifying Component Dependencies
446(1)
Identifying Scripting Requirements
447(2)
Lab 3: Creating a Setup Project
449(2)
Lesson Summary
451(1)
Lesson Review
451(2)
Lesson 4: Understanding an Application Flow-Logic Diagram
453(5)
Software Diagrams
453(1)
Application Flow-Logic Diagrams
454(1)
Identifying Component Complexity
455(1)
Lesson Summary
456(1)
Lesson Review
456(2)
Lesson 5: Validating the Production Configuration Environment
458(4)
Validate a Deployed Application
458(2)
Production Monitoring
460(1)
Lesson Summary
460(1)
Lesson Review
460(2)
Chapter Review
462(1)
Chapter Summary
462(1)
Key Terms
463(1)
Case Scenarios
463(1)
Suggested Practices
464(1)
Deploy and Monitor an Application
464(1)
Take a Practice Test
464(1)
Answers 465(36)
Glossary 501(6)
Index 507


Bruce Johnson is a 25-year veteran of the computer industry with a passion for system design and development. He coauthored MCPD Self-Paced Training Kits for Exams 70-548 and 70-547. Brian C. Lanham is a UNIX and MS-DOS veteran who now specializes in Windows- and Web-based applications. He coauthored the MCPD Self-Paced Training Kit for Exam 70-547. Shawn Wildermuth, Microsoft MVP for C#, has 20+ years experience building data-driven software. Hes coauthored several Self-Paced Training Kits, including that for Exam 70-536. GrandMasters is an IT consulting firm specializing in content development, exam development, and customized technical support.