Docstoc

.Summit - Roadmap

Document Sample
.Summit - Roadmap Powered By Docstoc
					         Architecture and
             Design
           (and a touch of
          implementation)
             for .NET
           Keith Pleas
           keithp@guideddesign.com
1 - 65                               Vermont .NET
                   Agenda
   •     Motivation
   •     An Architectural Framework
   •     Where Design Patterns fit it
   •     Microsoft’s Patterns & Practices
   •     Microsoft’s Application Blocks

   • What this means to you

2 - 65                                 Vermont .NET
              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
3 - 65                                               Vermont .NET
      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, Vermont .NET
4 - 65
         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




5 - 65                                Vermont .NET
         Can We Learn From Other
               Industries?
   • Architecture from other domains
         – Physical architecture
         – Manufacturing


   • Bottom line: We have no “protection”




6 - 65                                 Vermont .NET
         Architectural
          Framework


7 - 65                   Vermont .NET
     Zachman     Relating Theories

                              •Data
                B-A-I-T       •Application
                              •Deployment
                              •Infrastructure
                              D- A - D - I

               •Business                        Layers
               •Application
               •Information
               •Technical

8 - 65                                           Vermont .NET
         Architectural Framework
                    Business Informatio Applicatio Technolo
                                  n         n         gy
                    e.g., usage      e.g., entity     e.g., service    e.g., service
                    scenarios,       relationship     factoring        distribution
  Conceptual        business         modeling
                    models

                    e.g., workflow   e.g., schemas    e.g., service    e.g., server
                    models           and document     definitions,     mappings,
          Logical                    specifications   object models    “abilities”
                                                                       strategy

                    e.g., process    e.g., Db         e.g., detailed   e.g., product
                    specifications   layouts,         design           mappings,
         Physical                    repository                        network layout
                                     interfaces



9 - 65                                                                    Vermont .NET
            Business Architecture
                    Business Informatio Applicatio Technolo
                                  n         n         gy
                    e.g., usage      e.g., entity     e.g., service    e.g., service
                    scenarios,       relationship     factoring        distribution
  Conceptual        business         modeling
                    models

                    e.g., workflow   e.g., schemas    e.g., service    e.g., server
                    models           and document     definitions,     mappings,
          Logical                    specifications   object models    “abilities”
                                                                       strategy

                    e.g., process    e.g., Db         e.g., detailed   e.g., product
                    specifications   layouts,         design           mappings,
      Physical                       repository                        network layout
                                     interfaces



10 - 65                                                                   Vermont .NET
          Information Architecture
                    Business Informatio Applicatio Technolo
                                  n         n         gy
                    e.g., usage      e.g., entity     e.g., service    e.g., service
                    scenarios,       relationship     factoring        distribution
  Conceptual        business         modeling
                    models

                    e.g., workflow   e.g., schemas    e.g., service    e.g., server
                    models           and document     definitions,     mappings,
          Logical                    specifications   object models    “abilities”
                                                                       strategy

                    e.g., process    e.g., Db         e.g., detailed   e.g., product
                    specifications   layouts,         design           mappings,
      Physical                       repository                        network layout
                                     interfaces



11 - 65                                                                   Vermont .NET
          Technology Architecture
                    Business Informatio Applicatio Technolo
                                  n         n         gy
                    e.g., usage      e.g., entity     e.g., service    e.g., service
                    scenarios,       relationship     factoring        distribution
  Conceptual        business         modeling
                    models

                    e.g., workflow   e.g., schemas    e.g., service    e.g., server
                    models           and document     definitions,     mappings,
          Logical                    specifications   object models    “abilities”
                                                                       strategy

                    e.g., process    e.g., Db         e.g., detailed   e.g., product
                    specifications   layouts,         design           mappings,
      Physical                       repository                        network layout
                                     interfaces



12 - 65                                                                   Vermont .NET
          Application Architecture
                    Business Informatio Applicatio Technolo
                                  n         n         gy
                    e.g., usage      e.g., entity     e.g., service    e.g., service
                    scenarios,       relationship     factoring        distribution
  Conceptual        business         modeling
                    models

                    e.g., workflow   e.g., schemas    e.g., service    e.g., server
                    models           and document     definitions,     mappings,
          Logical                    specifications   object models    “abilities”
                                                                       strategy

                    e.g., process    e.g., Db         e.g., detailed   e.g., product
                    specifications   layouts,         design           mappings,
      Physical                       repository                        network layout
                                     interfaces



13 - 65                                                                   Vermont .NET
          Design Patterns



14 - 65                 Vermont .NET
          What Is A Pattern?

                    Context



          Problem             Solution




15 - 65                                  Vermont .NET
                      Patterns
   • Provide reuse and
     repeatability
   • Design and Architectural
          – eCommerce Application
          – Model-View-Controller
            (MVC)
          – Fiefdoms / Emissaries
          – Data Access Layer
          – Class Factory
          – N-tier Design
16 - 65                             Vermont .NET
               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


17 - 65                                        Vermont .NET
               Singleton Pattern
   •      Solution:




18 - 65                            Vermont .NET
                 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
           }

19 - 65                                                               Vermont .NET
            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?
20 - 65                                         Vermont .NET
            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



21 - 65                                         Vermont .NET
            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.




22 - 65                                          Vermont .NET
               Layered Architecture
                     Pattern




                                                                          Communication


                                                                                          Operational Management


                                                                                                                    Security
                                   Users




                             UI Components

                         UI Process Components


                            Service Interfaces

           Business            Business               Business Entities
           Workflows          Components



          Data Access Components                 Service Agents


      Data
      Sources                              Services


23 - 65                                                                                                            Vermont .NET
               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

24 - 65                                           Vermont .NET
        Model-View-Controller
               Pattern
• Separates the modeling of
  the domain, the
  presentation, and the
  actions based on user input                 Controller
  into three separate classes
  – Model - manages the
      behavior and data of the        Model
      application domain, responds
      to requests for information
      about its state, and responds             View
      to instructions to change
      state.
  – View - manages the display.
  – Controller - interprets the
      user input, informing the
25 - 65
      model and/or the view to                    Vermont .NET
          M-V-C in ASP.NET
 • Separates the code,
   the presentation, and
   actions                           Controller

    – Model – Code-behind
                             Model
    – View - HTML
    – Controller – ASP.NET
                                       View
      engine (page
      controller)



26 - 65                                Vermont .NET
                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
27 - 65   invocation by encapsulating them into a layer
                                                     Vermont .NET
                  Broker (Continued)
   • Discussion Points
          –   Location Transparency
          –   Server Lookup
          –   Broker as Intermediary
          –   Security Concerns

   • Benefits
          – Separation of Concerns
          – Complexity Management
          – Flexibility

   • Liabilities
          – Performance

28 - 65                                Vermont .NET
          Microsoft
          Patterns &
           Practices


29 - 65                Vermont .NET
                 Patterns & Practices:
                    Product Model
                  Business                         Technology                            Operational
                 Opportunities                      Solutions                             Execution


                 ENVISION            PLAN                BUILD                     DEPY       OPERATE

                   Reference                   Reference Building              Operational
                   Architectures               Blocks                          Practices
                      Business                   Little or No Business          Operational Best
                       Requirements                Context                         Practices
                      Non-functional             Non-functional                 Instantiation of MOF
                       Requirements                Requirements                    Within Solution Context
                      Technical Constraints      Technical Constraints
                      IT System Scope            Sub-System Level
                                                   Scope


                      Architecture /             Build /                    Deployment        Operational
    patterns &         Design Guide                Implement Guide             Guide              Guide
    practices         Sample Application         Source Code                Templates         Templates
                      Templates                  Templates

30 - 65                                                                                       Vermont .NET
               The Pattern Graph

                 Data   Application   Deployment Infrastructure

Architecture


Design


Implementation




31 - 65                                              Vermont .NET
          Constraining The Graph
    OLTP   Object Oriented   Layered Architecture Tiered Distribution

                    Data      Application   Deployment Infrastructure

Architecture


Design


Implementation




32 - 65                                                    Vermont .NET
                 Pattern Clusters


                  Data   Application   Deployment Infrastructure

Architecture
                                        Deployment
                         Components
Design
                         Presentation
                                   Security
Implementation            Framework




33 - 65                                              Vermont .NET
      Web Presentation Cluster
                                     Design
   Page Cache                          MVC                          Intercepting
                                                                        Filter


                   Page Controller              Front Controller




                              Implementation



                                   Implementing
   Implementing
                                       MVC
    Page Cache      Implementing with ASP.Net    Implementing        Implementing
    with ASP.Net   Page Controller              Front Controller   Intercepting Filter
                     with ASP.Net                 with ASP.Net        with ASP.Net

34 - 65                                                                Vermont .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 Controller
   • Use the Page interface code is time-consuming
      pattern to accept input from the
      page request, invoke the
      requested actions on the
      model, and determine the
      correct view to use for the
35 - 65                                                     Vermont .NET
            Implementing Page
           Controller in ASP.NET
   • Benefits
          – Simplicity
          – Leverages Framework
            features
          – Increased reuse
   • Liabilities
          – One controller per
            page
          – Deep inheritance trees

36 - 65                              Vermont .NET
                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.
37 - 65                                                    Vermont .NET
      The Deployment Problem




38 - 65                   Vermont .NET
                                                                  D    A    D     I


  Deployment Cluster                                      A
                                                          D
                                                           I


            Application              Deployment                Infrastructure
                                                                   Tiered
          Layered Application
                                                                Distribution


                                       Deployment



Rich Client DNA      .Net App                             IDC         EDC   DDC




                     Simple Web Complex Web Ext. Ent Rich Client



39 - 65                                                               Vermont .NET
                Deployment Patterns
     Simple Web App       Complex Web App     Extended Enterprise   Ent. Smart Client

      Web Clients         Web Clients           Web Clients           Smart Clients
                                                                       UIC

                                                                       UIP


                                                Web Farm
                          Web Farm
      Web Farm                                   UIC       SI        Web Farm
                            UIC
          UIC                                    UIP                   SI
                            UIP
          UIP                                     SA                   SA

          BC

          DAC             Application Farm      Application Farm     Application Farm
                            BC                    BC                   BC

                           DAC                   DAC                  DAC




      Database Clusters   Database Clusters     Database Clusters    Database Clusters




40 - 65                                                                     Vermont .NET
                                                              D    A      D   I


   Deployment Cluster                                  A
                                                       D
                                                       I




          Application             Deployment               Infrastructure

      Business Component
                                                             Clustering


                                Policies    Zone
                                                   Load Balancing


   Entity Process Utility
                                                                       Failover



                            Policy Store   PEP
                                                   Hardware Software

41 - 65                                                           Vermont .NET
          Microsoft
      Application Blocks


42 - 65               Vermont .NET
   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
43 - 65                                              Vermont .NET
  Sample App – E-Commerce Application
                                        Application Blocks for .NET




                                                                                                                 Communication


                                                                                                                                   Security


                                                                                                                                              Operational Management
                                                              Presentation Services
                                                                                           User Interface
                                                                                           Process (UIP)       Exception Mgmt


                                                                                                               Enterprise
                                                                Business Services
                                                                                                               Instrumentation
                                                                                                  Caching
                                                                        Data                                   Configuration
                                                                        Aggregation
                                             Data Services                            Service Integration
                                                                                                               Application
                                         Data Access                                      Persistent           Authorization
                                                                                          Asynchronous
                                         (SQL,   plan: Oracle, OleDB)                     Invocation


                                                        Data Sources                  Services


                                                                                                            Team Dev –
                                                                                                            Operational
                                                                                                            Build Scripts
Shipped
                                                                                                              Guides
                                                                                                            (Partner)
In Beta
In Development
44 - 65                                                                                                                          Vermont .NET
          Data Access Application
                  Block
   • Simplifies calling ADO.NET SqlClient
          –
          dr   = SqlHelper.ExecuteReader(
                      CONN_STRING,“SaveCustomer", “John” , “Doe” );

   • 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)
45 - 65                                                     Vermont .NET
Data Access Application Block




46 - 65                 Vermont .NET
     Choosing a DAAB Method

 •                 the response format
     First, choose target data source
     Then
 •   …and finally, what type of parameters
     you want to send
     – Int
       Connection String
     –
     –   Value Array
         DataSet
         SqlConnection
     –
     –   SqlParameter Arrays
         SqlDataReader
         SqlTransaction
     –
     –   No Parameters
         Object
     – XmlReader
SqlHelper
SqlHelper.ExecuteDataset(
SqlHelper.ExecuteDataset(“connectionstring”,
SqlHelper.ExecuteDataset(“connectionstring”
CommandType.StoredProcedure,
47 - 65 ”CustomersGetByPlanet”, “Earth”); Vermont .NET
  demo

            Data Access
          Application Block


48 - 65                  Vermont .NET
          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/Wor
               kspace.aspx?id=c20d12b0-af52-402b-9b7c-
               aaeb21d1f431

49 - 65                                                  Vermont .NET
                      DAAB Tips
   • ‘Privatize’ functions you don’t need
   • Things you can add
          –   Connection String Mgmt
          –   Batch Updates*
          –   Typed Datasets*
          –    * Next rev
          –   Instrumentation, etc.



50 - 65                                 Vermont .NET
                 ExceptionManager
   • Simplifies managing Exceptions
          try {…}
          catch( Exception ex )
          {
              ExceptionManager.Publish (ex )
          }

   • 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

51 - 65                                          Vermont .NET
      Exception Management




52 - 65                 Vermont .NET
                Exception Mgmt App
                       Block
  •       Runtime flexibility, pluggable design
          <configuration>
           <configSections>
            <section name="exceptionManagement"
                      type=" Microsoft.ApplicationBlocks.ExceptionManagement
                      .ExceptionManagerSectionHandler,
                      Microsoft.ApplicationBlocks.ExceptionManagement" />
           </configSections>

           <exceptionManagement mode="on/off">
            <publisher mode="on/off" assembly="AssemblyName"
             type="TypeName"
                  exclude=“[*]Type,Type"
                  include=“[+]Type,Type"
                  exceptionFormat="xml"
                  customattr = "value" />
           </exceptionManagement>
          </configuration>
53 - 65                                                                        Vermont .NET
     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
54 - 65                         Vermont .NET
          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
                                                             <navigationGraph
                                                                   iViewManager="WinFormViewManager"
                                                                   name="Shopping"
                                                                   state="State"
                                                                   statePersist="SqlServerPersistState"
                                                                   startView="cart">
    browsecatalog
                                                                   <node view="cart">
                                                                   <navigateTo navigateValue="resume"
                                                                        view="browsecatalog" />
addItem     fail                             resume                <navigateTo navigateValue="checkout" view="checkout"
                                                                        />
                                          view="browsecatalog">
                                   <node congrats                  <navigateTo navigateValue="fail" view="error" />
                                                                   </node>
                           error        <navigateTo navigateValue="addItem"
                                                        <node view="browsecatalog">
     resume                             view="cart"/> <navigateTo navigateValue="addItem" view="cart"/>
                                                        <navigateTo navigateValue="fail" view="error" />
                         resume         <navigateTo navigateValue="fail"
                                                        </node>

                                        view="error" /> <node view="error">
                                                        <navigateTo navigateValue="resume" view="cart" />
          fail                          passCheckout
                                   </node>              </node>

                                                                  <node view="checkout">
   cart                                     checkout              <navigateTo navigateValue="passCheckout"
                                                                       view="congrats" />
                    checkout                                failCheckout navigateValue="failCheckout"
                                                                  <navigateTo
                                                                       view="checkout" />
                                                                  </node>

                                                                   <node view="congratulations">
                                                                   <navigateTo navigateValue="resume" view="cart" />
55 - 65                                                            </node>
                                                             </navigationGraph>                   Vermont .NET
             UIP In Your Application
           Your ASP.NET Pages or            Your Windows Forms
                                           Your Windows Forms
          Your ASP.NET Pages or
       Windows Form,s
      Your ASP.NET Pages
       Windows Form,s                      Your Windows Forms
          WebFormView
          WebFormView                      WinFormView
                                           WinFormView
      WebFormView                          WinFormView




                                                Your State Type
                                                (Optional)
                                                State
                  ControllerBase                                                Persistence Providers:
                  Your Controller                    State Persistence          - SQL Server
                                                    State Persistence
                  Class                              Provider
                                                   State
                                                    Provider                    - Encrypted SQL Server
                   MyFunc()                        Persistence
                   {
                                                   Provider                     - Memory
                      //do cool code

                   }
                     //more good stuff                                          - ASP.NET Session
                                                                                - Custom
                                                                            View Manager
                                                UIP Manager                View Manager
                                                                           View
            Biz
           Biz                                                                             View Managers:
                                                                           Manager
            Component
           Components                                                                      - Windows Forms
            s
                                                                                           - Web Pages
                                    DALC
                                                UIP Configuration
                                   DALC
                                Data
                               Access
                                                                         Application XML
56 - 65                                                                  Configuration File         Vermont .NET
                      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
57 - 65
        – UIP sets the reference for you            Vermont .NET
  demo
  User Interface Process
           Block



58 - 65              Vermont .NET
      Configuration Management AB
  •       Secure configuration in multiple sources
  •       Helps maintain application configuration
  •       Pluggable Storage
  •       Pluggable Signing & Encryption
  •       Caching of config data for performance




59 - 65                                         Vermont .NET
        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">

      <configProvider
              assembly="Microsoft.ApplicationBlocks.ConfigurationManagement.Storage.XML,
              Version=1.0.0.4,Culture=neutral, PublicKeyToken=3325ee11de9ffa0a"
              type="Microsoft.ApplicationBlocks.ConfigurationManagement.Storage.XmlFileStorage"
              signed="false"
              refreshOnChange="true"
              encrypted="false" />
      <configCache
              enabled="true"
              locationPath=""
              locationType="Memory"
              refresh="1 * * * *"
              signed="true" encrypted=“false" />

     </configSection>


60 - 65                                                                            Vermont .NET
          Configuration Mgmt Design
                        Configuration                    Caching Service
          Your
       Application
                        Manager
                                                          Configuration Storage Provider
                                                         Configuration Storage Provider
                                                        Configuration Storage Provider
    Application XML
    Configuration
    File                                                                      Configuration Storage
    (holds config for
                                                          Data Protection
                                                         Data Protection
                                                          Provider
                                                                              Providers:
    config)                  Configuration Section       Data
                                                         Provider
                            Configuration Section
                                   Handlers                                   - XML File
                           Configuration
                                  Handlers               Protection
                                                         Provider
                                                                              - SQL Server
                             Section
                            Handlers                                          - Registry
                                                                              - Custom
                                                     Data Protection Providers:
                                                     - DPAPI
                                                     - BCL
                                                     - Custom



61 - 65                                                                                    Vermont .NET
      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
62 - 65                                        Vermont .NET
            Using the Updater AB
              Client                                                                   Server




                                                                     Poll & Download
                              2                                                             Application
          Update Controller                                                                 Update
                                                        Downloader
           (Application or           Updater           Downloader
                                                       Downloader
            separate EXE)            Application
                                                   3
                                     Block
                                                        Validator
                                                       Validator
              Controller XML
                                                   4                                   1
             Configuration File                                                             Administrator
                                                                                            uses Manifest
               File Copy                               Post Processor                       Utility
                                                       (optional)
                                                   5
                                                                                 Manifest



                       Application




63 - 65                                                                                            Vermont .NET
            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


64 - 65                                       Vermont .NET
          Summary
   • Where are we in the
     cycle?
   • Where do you fit in?
   • Where should you make
     your investment?

65 - 65                  Vermont .NET
             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)
66 - 65                               Vermont .NET
          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
67 - 65                                      Vermont .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 Vermont .NET
68 - 65
          …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
69 - 65                                    Vermont .NET

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:2
posted:11/24/2012
language:English
pages:69