.Summit - Roadmap
Upcoming SlideShare
Loading in...5
×
 

.Summit - Roadmap

on

  • 844 views

 

Statistics

Views

Total Views
844
Views on SlideShare
844
Embed Views
0

Actions

Likes
0
Downloads
5
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET Build: Start Top: The Problem - Sets of challenges across the solution’s life cycle Bottom: The Solution – Microsoft Prescriptive Guidance Click The MSF project phases. Can be generalized into decision/task sets. Generic Life Cycle decision/task sets: Architect/Design, Implement, Deploy, Operate MSF: Plan, Build, Deploy, Operate Click Solving the Business challenges as a software systems results in a solution and solution design/architecture. MSPG provides Reference Architectures as guidance. RAs provide generalized architectural solutions for common business scenarios. The actual RA is described in the Architecture/Design Guide, a Sample Application is provided to demonstrate the RA, and templates to help the architect consume the RA. Each of the RAs are based on one or more Architectural Styles. An Architectural style is a set of architectural principles which are useful when designing solutions based on a constrained set of technologies. Other examples are: client server, DNA, n-tier, hub-spoke, etc. Our Canonical .NET Architecture style is based on a combination of antonymous computing and services based design. Click While the solution architecture is being completed and while the solution is being implemented, many technical challenges will be need to be addressed. Reference Building Blocks are guidance typically for the developer. It provides guidance to many common technical challenges that are encountered in many solutions. RBBs are in the form of build/implementation guides, the solutions is demonstrated in great detail via source code, and the template help the developers consume the guidance. Click Finally once the solution is build and while the solution is being designed and implemented, a number of deployment and operational issues will be identified. The deployment and operational guides are indented to guide the IT professional and administrators. The templates help them consume the guidance. Patterns Patterns exist everywhere at all levels. Architectural patterns are captured in the Architectural Styles and leveraged in the RA. Traditional Gamma level patterns are leveraged in the RBBs Model relationships Architectural Style Informs Solution Design (Reference Architecture) Scenario Informs Solution Design (Reference Architecture) Scenario Contextualizes Architectural Style Solution Implementation (Reference Building Blocks) Realizes Solution Design (Reference Architectures) Solution Implementation (Reference Building Blocks) and Solution Design Reference Architecture) Informs Operational Challenges Design Patterns Informs Solution Implementation – catalogue of patterns Operational Challenges Informs Solution Management Solution Management Solves Operational Challenges Package can be any combination of delivery types Definitions: Reference Architectures are IT system level architectures that address the business requirements, non-functional requirements, and technical constraints for commonly occurring customer scenarios. Examples: Microsoft Systems Architecture - Internet Data Center Reference Architecture for Commerce v2.0 Microsoft Exchange 2000 Server Upgrade Series Microsoft Active Directory Branch Office Guide Microsoft Exchange 2000 Server Hosting Series References Building Blocks are re-usable designs that address common technical challenges across a wide range of customer scenarios. Many include tested, production quality source code to accelerate development. Examples: Data Access for .NET Exception Management in .NET Authentication in ASP.NET: .NET Security Guidance Monitoring in .NET Distributed Application Design Microsoft .NET/COM Migration and Interoperability Operational Practices provide guidance for deployment and operations of solutions in production environments and are based on the Microsoft IT Lifecycle Frameworks. Examples: Microsoft Security Operations Guide for Windows 2000 Server Microsoft Exchange 2000 Server Operations Guide Microsoft SQL Server 2000 Operations Guide Backup and Restore for Internet Data Center Team Development with Visual Studio .NET and Visual SourceSafe
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • what we’ll tell you: what is the PAG team and what we do and how it relates to other groups, how we work, what projects we have for .net – with a focus on the application blocks for .net program We’ll drill down into published .NET guidance Tell you how we want to engage with YOU Start a dialog and initiate questions.
  • split out and specify it is a
  • DataSet ds; string sConn = "SERVER=(local); INITIAL CATALOG=Pubs; INTEGRATED SECURITY=sspi;"; ds = SqlHelper.ExecuteDataset(sConn,CommandType.Text,"SELECT * FROM Authors"); dataGrid1.DataSource = ds.Tables[0];
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET
  • Copyright Microsoft 2001 July 15, 2001 Module 03: Visual Studio .NET

.Summit - Roadmap .Summit - Roadmap Presentation Transcript

  • Architecture and Design (and a touch of implementation) for .NET Keith Pleas [email_address]
  • Agenda
    • Motivation
    • An Architectural Framework
    • Where Design Patterns fit it
    • Microsoft’s Patterns & Practices
    • Microsoft’s Application Blocks
    • What this means to you
  • Problem Statement
    • Unsuccessful IT projects - CIO Survey
      • 73% of IT projects considered failures
        • Not on time or budget, don’t meet requirements
      • 50% of time considered “churn time”
        • Unproductive time, not directly related to deliverable
    • Lack of standard target architectures
    • Disconnect between dev and operations
  • Goals Of Architecture: The Customer Perspective
    • To let the business missions, strategies, and processes guide the use of information technology
    • To allow for the rapid adoption of new technologies for the competitive advantage of the enterprise
    • To provide for the rapid development and deployment of customized solutions
    • To enable repeatable, predictable, maintainable results
  • Why Should You Care?
    • The computing industry is maturing
    • Maturity leads to commoditization
    • Commoditization pushes down the stack to the lowest cost producer
    • To stay ahead, must add value that’s difficult to commoditize
  • Can We Learn From Other Industries?
    • Architecture from other domains
      • Physical architecture
      • Manufacturing
    • Bottom line: We have no “protection”
  • Architectural Framework
  • Relating Theories Zachman B - A - I - T D- A - D - I Layers
    • Business
    • Application
    • Information
    • Technical
    • Data
    • Application
    • Deployment
    • Infrastructure
  • Architectural Framework e.g., product mappings, network layout e.g., detailed design e.g., Db layouts, repository interfaces e.g., process specifications Physical e.g., server mappings, “abilities” strategy e.g., service definitions, object models e.g., schemas and document specifications e.g., workflow models Logical e.g., service distribution e.g., service factoring e.g., entity relationship modeling e.g., usage scenarios, business models Conceptual Technology Application Information Business
  • Business Architecture e.g., product mappings, network layout e.g., detailed design e.g., Db layouts, repository interfaces e.g., process specifications Physical e.g., server mappings, “abilities” strategy e.g., service definitions, object models e.g., schemas and document specifications e.g., workflow models Logical e.g., service distribution e.g., service factoring e.g., entity relationship modeling e.g., usage scenarios, business models Conceptual Technology Application Information Business
  • Information Architecture e.g., product mappings, network layout e.g., detailed design e.g., Db layouts, repository interfaces e.g., process specifications Physical e.g., server mappings, “abilities” strategy e.g., service definitions, object models e.g., schemas and document specifications e.g., workflow models Logical e.g., service distribution e.g., service factoring e.g., entity relationship modeling e.g., usage scenarios, business models Conceptual Technology Application Information Business
  • Technology Architecture e.g., product mappings, network layout e.g., detailed design e.g., Db layouts, repository interfaces e.g., process specifications Physical e.g., server mappings, “abilities” strategy e.g., service definitions, object models e.g., schemas and document specifications e.g., workflow models Logical e.g., service distribution e.g., service factoring e.g., entity relationship modeling e.g., usage scenarios, business models Conceptual Technology Application Information Business
  • Application Architecture e.g., product mappings, network layout e.g., detailed design e.g., Db layouts, repository interfaces e.g., process specifications Physical e.g., server mappings, “abilities” strategy e.g., service definitions, object models e.g., schemas and document specifications e.g., workflow models Logical e.g., service distribution e.g., service factoring e.g., entity relationship modeling e.g., usage scenarios, business models Conceptual Technology Application Information Business
  • Design Patterns
  • What Is A Pattern? Context Problem Solution
  • Patterns
    • Provide reuse and repeatability
    • Design and Architectural
      • eCommerce Application
      • Model-View-Controller (MVC)
      • Fiefdoms / Emissaries
      • Data Access Layer
      • Class Factory
      • N-tier Design
  • Singleton Pattern
    • Context :
      • Control access to a class by controlling its instantiation process
    • Problem :
      • Certain types of data need to be globally accessed and maintained
      • This data is often unique in the system
      • E.G. counter class
  • Singleton Pattern
    • Solution:
  • Singleton Pattern
    • Solution :
    public class Counter { private static Counter _instance = null; private Counter() {} public static Counter getInstance() { if (_instance==null) { _instance = new Counter(); } return _instance; } //... functions provided by Counter }
  • Layered Architecture Pattern
    • Context:
      • You are designing a complex enterprise application composed of a large number of components across multiple levels of abstraction
    • Problem:
      • How do you structure an application to support such operational requirements such as maintainability, reusability, scalability, robustness and security?
  • Layered Architecture Pattern
    • Forces:
      • Changes in one part of the app should have minimal impact to other parts
      • Separation of concerns is desirable
      • Portions of the app should be reusable
      • Strong cohesion, loose coupling is desired
      • Portions of the app will be maintained and evolved independently
  • Layered Architecture Pattern
    • Solution:
      • Compose the solution into a set of layers. Each layer should be cohesive and at roughly the same level of abstraction. Each layer should be loosely coupled to the layers underneath.
  • Layered Architecture Pattern UI Components UI Process Components Data Access Components Business Workflows Business Components Users Business Entities Service Agents Service Interfaces Data Sources Services Operational Management Security Communication
  • Command Pattern
    • A request object
    • Allows creating requests of unspecified application objects
    • Common examples
      • A request created by a menu item selection
      • A request that pastes text from the clipboard into a document
      • Execution macros
  • Model-View-Controller Pattern
    • Separates the modeling of the domain, the presentation, and the actions based on user input into three separate classes
      • Model - manages the behavior and data of the application domain, responds to requests for information about its state, and responds to instructions to change state.
      • View - manages the display.
      • Controller - interprets the user input, informing the model and/or the view to change as appropriate.
    Model View Controller
  • M-V-C in ASP.NET
    • Separates the code, the presentation, and actions
      • Model – Code-behind
      • View - HTML
      • Controller – ASP.NET engine (page controller)
    Model View Controller
  • Broker Pattern
    • Problem
      • How can you structure a distributed system so that application developers don’t have to concern themselves with the details of remote communication?
    • Forces
      • Distributed communication complexity
      • Deployment Flexibility
      • Specialized Skills
    • Solution
      • Use the Broker pattern to hide the implementation details of remote service invocation by encapsulating them into a layer other than the business component itself
  • Broker (Continued)
    • Discussion Points
      • Location Transparency
      • Server Lookup
      • Broker as Intermediary
      • Security Concerns
    • Benefits
      • Separation of Concerns
      • Complexity Management
      • Flexibility
    • Liabilities
      • Performance
  • Microsoft Patterns & Practices
  • Patterns & Practices: Product Model patterns & practices Operational Execution Technology Solutions Business Opportunities PLAN BUILD DEPY OPERATE ENVISION
    • Reference Architectures
      • Business Requirements
      • Non-functional Requirements
      • Technical Constraints
      • IT System Scope
    • Architecture / Design Guide
    • Sample Application
    • Templates
    • Reference Building Blocks
      • Little or No Business Context
      • Non-functional Requirements
      • Technical Constraints
      • Sub-System Level Scope
    • Build / Implement Guide
    • Source Code
    • Templates
    • Deployment Guide
    • Templates
    • Operational Guide
    • Templates
    • Operational Practices
      • Operational Best Practices
      • Instantiation of MOF Within Solution Context
  • The Pattern Graph Data Implementation Design Architecture Infrastructure Deployment Application
  • Constraining The Graph OLTP Object Oriented Layered Architecture Tiered Distribution Data Implementation Design Architecture Infrastructure Deployment Application
  • Pattern Clusters Security Data Implementation Design Architecture Infrastructure Deployment Application Components Deployment Presentation Framework
  • Web Presentation Cluster MVC Front Controller Page Cache Intercepting Filter Implementing MVC with ASP.Net Implementing Front Controller with ASP.Net Implementing Intercepting Filter with ASP.Net Implementing Page Cache with ASP.Net Implementation Design Page Controller Implementing Page Controller with ASP.Net
  • Page Controller
    • How do you best structure the controller for moderately complex Web applications so that you can achieve reuse and flexibility while avoiding code duplication?
      • MVC focuses primarily on the separation between model and view
      • Many dynamic Web pages involve similar steps: verifying user authentication, extracting query string parameters etc.
      • Testing user interface code is time-consuming
    • Use the Page Controller pattern to accept input from the page request, invoke the requested actions on the model, and determine the correct view to use for the resulting page.
  • Implementing Page Controller in ASP.NET
    • Benefits
      • Simplicity
      • Leverages Framework features
      • Increased reuse
    • Liabilities
      • One controller per page
      • Deep inheritance trees
  • Front Controller
    • How do you best structure the controller for very complex Web applications so that you can achieve reuse and flexibility while avoiding code duplication?
      • Page controller can lead to overburdened base classes
      • Inheritance hierarchy is static
      • Might need to coordinate processes across pages
      • Might deal with dynamic navigation paths, e.g. a ‘Wizard’ that includes optional pages
    • Front Controller solves the decentralization problem present in Page Controller by channeling all requests through a single controller.
  • The Deployment Problem
  • Deployment Cluster Layered Application Rich Client DNA .Net App Application Deployment Infrastructure IDC EDC DDC Tiered Distribution Deployment Simple Web Complex Web Ext. Ent Rich Client D I D A I D A
  • Deployment Patterns Web Clients Web Farm UIC BC DAC UIP Simple Web App Complex Web App Ent. Smart Client Extended Enterprise Database Clusters Database Clusters Application Farm BC DAC Web Clients Smart Clients UIC UIP Web Farm SI SA Database Clusters Web Farm UIC UIP Application Farm BC DAC Web Farm UIC UIP SI SA Web Clients Database Clusters Application Farm BC DAC
  • Deployment Cluster Business Component Entity Utility Application Deployment Infrastructure Failover Hardware Clustering Policies Policy Store Process PEP Zone Software Load Balancing D I D A I D A
  • Microsoft Application Blocks
  • EULA and Support Model
    • Source Code only – VB.NET and C#
      • No binaries - ‘As is’ EULA
        • Customizations OK
        • Redistribution & repackaging OK
    • Support
      • PSS sign-off
      • PSS Training
        • Consistency in recommendations
        • Escalation procedures, bug reporting
    • GotDotNet Community
  • Application Blocks for .NET Service Integration Business Services Presentation Services Data Services Services Data Sources Operational Management Security Communication Operational Guides Shipped Team Dev – Build Scripts (Partner) Persistent Asynchronous Invocation In Beta Application Authorization User Interface Process (UIP) Caching Data Access (SQL, plan: Oracle, OleDB ) Data Aggregation Configuration Exception Mgmt Sample App – E-Commerce Application Enterprise Instrumentation In Development
  • Data Access Application Block
    • Simplifies calling ADO.NET SqlClient
    • Simplifies returning many formats
      • Get DataSets, DataReaders, Scalars, XmlReaders – all in one line of code
    • Simplifies calling with many sources
      • Connections, Conn. Strings, SQL Transactions
      • Plays well with COM+
    • Best practices performance
      • Nile benchmarks (internal & competitive)
    dr = SqlHelper.ExecuteReader( CONN_STRING,“SaveCustomer", “John” , “Doe” );
  • Data Access Application Block
    • First, choose the response format
      • Int
      • DataSet
      • SqlDataReader
      • Object
      • XmlReader
    Choosing a DAAB Method SqlHelper SqlHelper.ExecuteDataset( SqlHelper.ExecuteDataset(“connectionstring”
    • Then choose target data source
      • Connection String
      • SqlConnection
      • SqlTransaction
    • … and finally, what type of parameters you want to send
      • Value Array
      • SqlParameter Arrays
      • No Parameters
    SqlHelper.ExecuteDataset(“connectionstring”, CommandType.StoredProcedure, ”CustomersGetByPlanet”, “Earth”);
  • Data Access Application Block demo
  • Data Access Application Block
    • Parameter Caching
      • Caches Stored Procedure Parameters
      • Avoids 2 roundtrips
      • Cache can be loaded manually (enforcing type manually) or automatically ‘on the fly’
    • Important Links
      • .NET Data Access Architecture Guide http://msdn.microsoft.com/library/en-us/dnbda/html/daag.asp
      • GotDotNet Workspace
        • http:// www.gotdotnet.com/Community/Workspaces/Workspace.aspx?id =c20d12b0-af52-402b-9b7c-aaeb21d1f431
  • DAAB Tips
    • ‘Privatize’ functions you don’t need
    • Things you can add
      • Connection String Mgmt
      • Batch Updates*
      • Typed Datasets*
      • * Next rev
      • Instrumentation, etc.
  • ExceptionManager
    • Simplifies managing Exceptions
    • Pluggable ‘Publishers’ of exception info
      • Event Log as default.
      • Filters for routing / verbosity
    • Adds troubleshooting information
    • Persists Exception Chain
    • Plans to extend with Enterprise Instrumentation Fx
    try {…} catch( Exception ex ) { ExceptionManager.Publish (ex ) }
  • Exception Management
  • Exception Mgmt App Block
    • Runtime flexibility, pluggable design
    <configuration> <configSections> <section name=&quot;exceptionManagement&quot; type=&quot; Microsoft.ApplicationBlocks.ExceptionManagement .ExceptionManagerSectionHandler, Microsoft.ApplicationBlocks.ExceptionManagement&quot; /> </configSections> <exceptionManagement mode=&quot; on / off &quot; > <publisher mode=&quot; on / off &quot; assembly=&quot; AssemblyName &quot; type=&quot; TypeName &quot; exclude=“[ * ] Type , Type &quot; include=“[ + ] Type , Type &quot; exceptionFormat=&quot; xml &quot; customattr = &quot; value &quot; /> </exceptionManagement> </configuration>
  • User Interface Process Block
    • Facilitates developing complex UI control
    • Helps you implement the MVC pattern
    • Describe your UI ‘flow’ as XML
    • Reuse controller logic for Windows & Web
    • Take care of state management
    • Start, pause and resume user tasks without having your code notice
  • A User Interface Process
    • A User Interface Process represents a ‘use case’
    • You can draw it as a flow between views
    • The UIP Block uses XML config to manage flow
    cart browsecatalog error checkout congrats addItem fail resume resume resume passCheckout failCheckout checkout fail
    • <navigationGraph
      • iViewManager=&quot;WinFormViewManager&quot;
      • name=&quot;Shopping&quot;
      • state=&quot;State&quot;
      • statePersist=&quot;SqlServerPersistState&quot;
      • startView=&quot;cart&quot;>
      • <node view=&quot;cart&quot;>
      • <navigateTo navigateValue=&quot;resume&quot; view=&quot;browsecatalog&quot; />
      • <navigateTo navigateValue=&quot;checkout&quot; view=&quot;checkout&quot; />
      • <navigateTo navigateValue=&quot;fail&quot; view=&quot;error&quot; />
      • </node>
      • <node view=&quot;browsecatalog&quot;>
      • <navigateTo navigateValue=&quot;addItem&quot; view=&quot;cart&quot;/>
      • <navigateTo navigateValue=&quot;fail&quot; view=&quot;error&quot; />
      • </node>
      • <node view=&quot;error&quot;>
      • <navigateTo navigateValue=&quot;resume&quot; view=&quot;cart&quot; />
      • </node>
      • <node view=&quot;checkout&quot;>
      • <navigateTo navigateValue=&quot;passCheckout&quot; view=&quot;congrats&quot; />
      • <navigateTo navigateValue=&quot;failCheckout&quot; view=&quot;checkout&quot; />
      • </node>
      • <node view=&quot;congratulations&quot;>
      • <navigateTo navigateValue=&quot;resume&quot; view=&quot;cart&quot; />
      • </node>
    • </navigationGraph>
    • <node view=&quot;browsecatalog&quot;>
    • <navigateTo navigateValue=&quot;addItem&quot; view=&quot;cart&quot;/>
    • <navigateTo navigateValue=&quot;fail&quot; view=&quot;error&quot; />
    • </node>
  • UIP In Your Application ControllerBase Your Controller Class DALC DALC Biz Components Biz Components Data Access MyFunc() { //do cool code //more good stuff } Persistence Providers: - SQL Server - Encrypted SQL Server - Memory - ASP.NET Session - Custom State Persistence Provider WebFormView Your ASP.NET Pages WinFormView Your Windows Forms WinFormView Your Windows Forms WebFormView Your ASP.NET Pages or Windows Form,s WebFormView Your ASP.NET Pages or Windows Form,s State Persistence Provider State Persistence Provider UIP Manager Application XML Configuration File UIP Configuration View Managers : - Windows Forms - Web Pages View Manager View Manager View Manager WinFormView Your Windows Forms State Your State Type (Optional)
  • UIP Code
    • Writing Controllers:
      • Inherit your class from ControllerBase
      • Use the State object to hold your process data
      • Use the NavigateValue property to set your output
      • Interact with your business layers
    • Writing Views:
      • Inherit your page from WebFormView
      • Inherit your Form from WinFormView
      • Use the MyController property to access the controller
      • UIP sets the reference for you
  • User Interface Process Block demo
  • Configuration Management AB
    • Secure configuration in multiple sources
    • Helps maintain application configuration
    • Pluggable Storage
    • Pluggable Signing & Encryption
    • Caching of config data for performance
  • Using the Config Management AB
    • Write your application as usual
    • Specify ‘config for the config’
      • Where config section stored, encrypted or not, caching policy
      • Includes utilities & QuickStarts for encryption
    <configSection name=“YourAppConfigSection&quot;> <configProvider assembly=&quot;Microsoft.ApplicationBlocks.ConfigurationManagement.Storage.XML, Version=1.0.0.4,Culture=neutral, PublicKeyToken=3325ee11de9ffa0a&quot; type=&quot;Microsoft.ApplicationBlocks.ConfigurationManagement.Storage.XmlFileStorage&quot; signed=&quot;false&quot; refreshOnChange=&quot;true&quot; encrypted=&quot;false&quot; /> <configCache enabled=&quot;true&quot; locationPath=&quot;&quot; locationType=&quot;Memory&quot; refresh=&quot;1 * * * *&quot; signed=&quot;true&quot; encrypted=“false&quot; /> </configSection>
  • Configuration Mgmt Design Your Application Application XML Configuration File (holds config for config) Configuration Storage Providers: - XML File - SQL Server - Registry - Custom Configuration Manager Data Protection Providers: - DPAPI - BCL - Custom Caching Service Configuration Section Handlers Configuration Section Handlers Configuration Section Handlers Configuration Storage Provider Data Protection Provider Data Protection Provider Data Protection Provider Configuration Storage Provider Configuration Storage Provider
  • Updater Application Block
    • ‘V Next’ of the popular GotDotNet Application Updater
    • Securely pull assemblies and files
    • Pluggable download mechanism
      • Includes BITS - Background Intelligent Transfer System
    • Run ‘custom actions’ post deployment
    • Downloads validated using RSA or custom validation
  • Using the Updater AB Update Controller (Application or separate EXE) Updater Application Block Application Update Manifest Application Poll & Download Controller XML Configuration File File Copy 1 Server Client Downloader 2 Administrator uses Manifest Utility Validator Post Processor (optional) 5 Downloader Downloader Validator 4 3
  • Upcoming Application Blocks
    • Other blocks in development
      • Caching, Asynch Invocation, Aggregation
    • Available July
    • Get beta blocks on GotDotNet workspaces
      • Get the code
      • Get samples
      • Get extra plug-ins
  • Summary
    • Where are we in the cycle?
    • Where do you fit in?
    • Where should you make your investment?
  • References
    • A Pattern Language: Towns/ Buildings/ Construction – Alexander (1977)
    • Design Patterns: Elements of Reusable Object-Oriented Software – Gamma, et al (1995)
    • Pattern-Oriented Software Architecture: A System of Patterns – (1996)
    • Pattern-Oriented Software Architecture Volume 2: Patterns for Concurrent and Networked Objects – (2000)
    • Patterns of Enterprise Application Architecture – Fowler (2003)
    • AntiPatterns – Brown, et al (1998)
  • MSDN Architecture Webcasts…
    • Architecting applications to leverage existing code
    • VS.NET Enterprise Architect
    • XML Web Services inside Microsoft
    • The role of virtualization in XML Web Services
    • J2EE & the .NET Platform within the Software Fortress
    • Microsoft TerraServer Architecture
    • Autonomous Computing Fiefdoms and Emissaries
    • Building Interoperable Web Services
    • .NET Interoperability with J2EE
    • Architecting Interoperable Web Services using .NET
  • MSDN Architecture Webcasts…
    • Design choices & performance in distributed .NET apps
    • Some architectural patterns for the enterprise
    • Architecting a .NET distributed application
    • ASP.NET Mobilizing Your Desktop Web Applications
    • .Net and J2EE interoperability
    • SQLXML XML Technology for SQL Server
    • XML Web Services Security
    • Legacy Enterprise Application Integration
    • ASP.NET Patterns and Idioms
    • An overview of Architecture
    • .Net and J2EE interoperability – update
    • .NET Architecture Center Overview
  • … MSDN Architecture Webcasts
    • The Future of XML Web Services
    • Networking in the Microsoft Systems Architecture
    • An Overview of Microsoft Systems Architecture
    • Customizing the Microsoft Systems Architecture
    • Security in the Microsoft Systems Architecture
    • Web Service Architecture - Deciphering WS- protocol
    • Using Patterns to Build Business Applications
    • Distributed LOB app design using Application Blocks