Vermont .NET1 - 65
Keith [email protected]
Architecture and Design (and a touch of
implementation)for .NET
Vermont .NET2 - 65
Agenda
• Motivation• An Architectural Framework• Where Design Patterns fit it• Microsoft’s Patterns & Practices• Microsoft’s Application Blocks
• What this means to you
Vermont .NET3 - 65
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
Vermont .NET4 - 65
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
Vermont .NET5 - 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
Vermont .NET6 - 65
Can We Learn From Other Industries?
• Architecture from other domains– Physical architecture– Manufacturing
• Bottom line: We have no “protection”
Vermont .NET7 - 65
Architectural Framework
Vermont .NET8 - 65
Relating TheoriesZachmanZachman
B - A - I - B - A - I - TT
D- A - D D- A - D - I- I
LayersLayers•BusinessBusiness•ApplicationApplication•InformationInformation•TechnicalTechnical
•DataData•ApplicationApplication•DeploymenDeploymentt•InfrastructuInfrastructurere
Vermont .NET9 - 65
Architectural Framework
Business Information
Application
Technology
Conceptual
e.g., usage scenarios, business models
e.g., entity relationship modeling
e.g., service factoring
e.g., service distribution
Logical
e.g., workflow models
e.g., schemas and document specifications
e.g., service definitions, object models
e.g., server mappings, “abilities” strategy
Physical
e.g., process specifications
e.g., Db layouts, repository interfaces
e.g., detailed design
e.g., product mappings, network layout
Vermont .NET10 - 65
Business Architecture
Business Information
Application
Technology
Conceptual
e.g., usage scenarios, business models
e.g., entity relationship modeling
e.g., service factoring
e.g., service distribution
Logical
e.g., workflow models
e.g., schemas and document specifications
e.g., service definitions, object models
e.g., server mappings, “abilities” strategy
Physical
e.g., process specifications
e.g., Db layouts, repository interfaces
e.g., detailed design
e.g., product mappings, network layout
Vermont .NET11 - 65
Information Architecture
Business Information
Application
Technology
Conceptual
e.g., usage scenarios, business models
e.g., entity relationship modeling
e.g., service factoring
e.g., service distribution
Logical
e.g., workflow models
e.g., schemas and document specifications
e.g., service definitions, object models
e.g., server mappings, “abilities” strategy
Physical
e.g., process specifications
e.g., Db layouts, repository interfaces
e.g., detailed design
e.g., product mappings, network layout
Vermont .NET12 - 65
Technology Architecture
Business Information
Application
Technology
Conceptual
e.g., usage scenarios, business models
e.g., entity relationship modeling
e.g., service factoring
e.g., service distribution
Logical
e.g., workflow models
e.g., schemas and document specifications
e.g., service definitions, object models
e.g., server mappings, “abilities” strategy
Physical
e.g., process specifications
e.g., Db layouts, repository interfaces
e.g., detailed design
e.g., product mappings, network layout
Vermont .NET13 - 65
Application Architecture
Business Information
Application
Technology
Conceptual
e.g., usage scenarios, business models
e.g., entity relationship modeling
e.g., service factoring
e.g., service distribution
Logical
e.g., workflow models
e.g., schemas and document specifications
e.g., service definitions, object models
e.g., server mappings, “abilities” strategy
Physical
e.g., process specifications
e.g., Db layouts, repository interfaces
e.g., detailed design
e.g., product mappings, network layout
Vermont .NET14 - 65
Design Patterns
Vermont .NET15 - 65
What Is A Pattern?
Context
Problem Solution
Vermont .NET16 - 65
Patterns
• Provide reuse and repeatability
• Design and Architectural– eCommerce Application– Model-View-Controller (MVC)– Fiefdoms / Emissaries– Data Access Layer– Class Factory– N-tier Design
Vermont .NET17 - 65
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
Vermont .NET18 - 65
Singleton Pattern
• Solution:
Vermont .NET19 - 65
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 }
Vermont .NET20 - 65
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?
Vermont .NET21 - 65
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
Vermont .NET22 - 65
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.
Vermont .NET23 - 65
Layered Architecture Pattern
UI ComponentsUI Components
UI Process ComponentsUI Process Components
Data Access ComponentsData Access Components
Business Workflows
Business Components
Users
Business Entities
Service AgentsService Agents
Op
eration
al Man
age
men
tO
peratio
nal M
anag
em
ent
Sec
urity
Sec
urity
Co
mm
un
ication
Co
mm
un
ication
Service Interfaces
Data Data SourcesSources ServicesServices
Vermont .NET24 - 65
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
Vermont .NET25 - 65
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.
ModelModel
ViewView
ControllerController
Vermont .NET26 - 65
M-V-C in ASP.NET
•Separates the code, the presentation, and actions–Model – Code-
behind–View - HTML –Controller –
ASP.NET engine (page controller)
ModelModel
ViewView
ControllerController
Vermont .NET27 - 65
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
Vermont .NET28 - 65
Broker (Continued)
• Discussion Points– Location Transparency– Server Lookup– Broker as Intermediary– Security Concerns
• Benefits– Separation of Concerns– Complexity Management– Flexibility
• Liabilities– Performance
Vermont .NET29 - 65
MicrosoftPatterns & Practices
Vermont .NET30 - 65
patterns &practices
Operational Operational ExecutionExecution
Technology Technology SolutionsSolutions
Business Business OpportunitiesOpportunities
Patterns & Practices:Product Model
PLAN BUILD DEPY OPERATEENVISION
Reference Reference ArchitecturesArchitectures BusinessBusiness
RequirementsRequirements Non-functional Non-functional
RequirementsRequirements Technical ConstraintsTechnical Constraints IT System ScopeIT System Scope
Architecture / Design Guide
Sample Application Templates
Reference Building Reference Building BlocksBlocks Little or No BusinessLittle or No Business
ContextContext Non-functional Non-functional
RequirementsRequirements Technical ConstraintsTechnical Constraints Sub-System Level Sub-System Level
ScopeScope
Build / Implement Guide
Source Code Templates
DeploymentGuide
Templates
OperationalGuide
Templates
Operational Operational PracticesPractices Operational BestOperational Best
PracticesPractices Instantiation of MOF Instantiation of MOF
Within Solution ContextWithin Solution Context
Vermont .NET31 - 65
The Pattern Graph
Data Application
Deployment
Infrastructure
Architecture
Design
Implementation
Vermont .NET32 - 65
Constraining The Graph
Data Application
Deployment
Infrastructure
Architecture
Design
Implementation
OLTPOLTP Object OrientedObject Oriented Layered ArchitectureLayered Architecture Tiered DistributionTiered Distribution
Vermont .NET33 - 65
Pattern Clusters
Data Application
Deployment
Infrastructure
Architecture
Design
Implementation
ComponentsDeployment
Presentation
FrameworkSecurity
Vermont .NET34 - 65
MVC
Front Controller
Page Cache Intercepting Filter
ImplementingMVC
with ASP.Net ImplementingFront Controller with ASP.Net
ImplementingIntercepting Filter
with ASP.Net
ImplementingPage Cache
with ASP.Net
Web Presentation Cluster
Implementation
Design
Page Controller
ImplementingPage Controller with ASP.Net
Vermont .NET35 - 65
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.
Vermont .NET36 - 65
Implementing Page Controller in ASP.NET
• Benefits– Simplicity– Leverages Framework
features– Increased reuse
• Liabilities– One controller per
page – Deep inheritance trees
Vermont .NET37 - 65
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.
Vermont .NET38 - 65
The Deployment Problem
Vermont .NET39 - 65
Deployment Cluster
Layered ApplicationLayered Application
Rich ClientRich Client DNADNA .Net App.Net App
ApplicationApplication DeploymentDeployment InfrastructureInfrastructure
IDCIDC EDCEDC DDCDDC
Tiered Tiered
DistributionDistribution
DeploymentDeployment
Simple WebSimple Web Complex WebComplex Web Ext. EntExt. Ent Rich ClientRich Client
D A D I
A
D
I
Vermont .NET40 - 65
Deployment Patterns
Web Clients
Web Farm
UICUIC
BCBC
DACDAC
UIPUIP
Simple Web App Complex Web App Ent. Smart ClientExtended Enterprise
Database ClustersDatabase Clusters
Application Farm
BCBC
DACDAC
Database Clusters
Web Clients
Web Farm
UICUIC
UIPUIP
Application Farm
BCBC
DACDAC
Web Farm
UICUIC
UIPUIP
SISI
SASA
Web Clients Smart Clients
UICUIC
UIPUIP
Database Clusters
Application Farm
BCBC
DACDAC
Web Farm
SISI
SASA
Vermont .NET41 - 65
Deployment ClusterD A D I
A
D
I
Business ComponentBusiness Component
EntityEntity UtilityUtility
ApplicationApplication DeploymentDeployment InfrastructureInfrastructure
FailoverFailover
HardwareHardware
ClusteringClustering
PoliciesPolicies
Policy StorePolicy Store
ProcessProcess
PEPPEP
ZoneZone
SoftwareSoftware
Load BalancingLoad Balancing
Vermont .NET42 - 65
MicrosoftApplication
Blocks
Vermont .NET43 - 65
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
Vermont .NET44 - 65
Service IntegrationService Integration
Application Blocks for .NET
Business ServicesBusiness Services
Presentation ServicesPresentation Services
Data ServicesData Services
ServicesData Sources
Operational M
anagement
Operational M
anagement
Security
Security
Com
munication
Com
munication
Operational Operational GuidesGuides
ShippedShippedTeam Dev – Build Scripts
(Partner)
Team Dev – Build Scripts
(Partner)
Persistent Asynchronous Invocation
Persistent Asynchronous Invocation
In BetaIn Beta
Application AuthorizationApplication Authorization
User Interface Process (UIP)User Interface Process (UIP)
CachingCaching
Data Access
(SQL, plan: Oracle, OleDB)
Data Access
(SQL, plan: Oracle, OleDB)
Data AggregationData Aggregation
Configuration Configuration
Exception MgmtException Mgmt
Sam
ple
Ap
p – E
-Com
merc
e A
pp
licatio
nS
am
ple
Ap
p – E
-Com
merc
e A
pp
licatio
n
Enterprise InstrumentationEnterprise Instrumentation
In DevelopmentIn Development
Vermont .NET45 - 65
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” );
Vermont .NET46 - 65
Data Access Application Block
Vermont .NET47 - 65
SqlHelperSqlHelper.ExecuteDataset(SqlHelper.ExecuteDataset(“connectionstring”
• First, choose the response format
– Int– DataSet– SqlDataReader– Object– XmlReader
• 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
Choosing a DAAB Method
SqlHelper.ExecuteDataset(“connectionstring”, CommandType.StoredProcedure,”CustomersGetByPlanet”, “Earth”);
Vermont .NET48 - 65
demodemo
Data Access Application
Block
Vermont .NET49 - 65
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
Vermont .NET50 - 65
DAAB Tips
• ‘Privatize’ functions you don’t need• Things you can add
– Connection String Mgmt– Batch Updates*– Typed Datasets*– * Next rev– Instrumentation, etc.
Vermont .NET51 - 65
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 ) }
Vermont .NET52 - 65
Exception Management
Vermont .NET53 - 65
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>
<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>
Vermont .NET54 - 65
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
Vermont .NET55 - 65
A User Interface Process
cartcart
browsecatalogbrowsecatalog
errorerror
checkoutcheckout
congratscongrats
addItem fail
resume
resume
resume
passCheckout
failCheckoutcheckout
fail
<navigationGraph iViewManager="WinFormViewManager"name="Shopping" state="State" statePersist="SqlServerPersistState"startView="cart">
<node view="cart"><navigateTo navigateValue="resume"
view="browsecatalog" /><navigateTo navigateValue="checkout"
view="checkout" /><navigateTo navigateValue="fail" view="error" /></node>
<node view="browsecatalog"><navigateTo navigateValue="addItem" view="cart"/><navigateTo navigateValue="fail" view="error" /></node>
<node view="error"><navigateTo navigateValue="resume" view="cart" /></node>
<node view="checkout"><navigateTo navigateValue="passCheckout"
view="congrats" /><navigateTo navigateValue="failCheckout"
view="checkout" /></node>
<node view="congratulations"><navigateTo navigateValue="resume" view="cart" /></node>
</navigationGraph>
<navigationGraph iViewManager="WinFormViewManager"name="Shopping" state="State" statePersist="SqlServerPersistState"startView="cart">
<node view="cart"><navigateTo navigateValue="resume"
view="browsecatalog" /><navigateTo navigateValue="checkout"
view="checkout" /><navigateTo navigateValue="fail" view="error" /></node>
<node view="browsecatalog"><navigateTo navigateValue="addItem" view="cart"/><navigateTo navigateValue="fail" view="error" /></node>
<node view="error"><navigateTo navigateValue="resume" view="cart" /></node>
<node view="checkout"><navigateTo navigateValue="passCheckout"
view="congrats" /><navigateTo navigateValue="failCheckout"
view="checkout" /></node>
<node view="congratulations"><navigateTo navigateValue="resume" view="cart" /></node>
</navigationGraph>
• 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
<node view="browsecatalog"><navigateTo navigateValue="addItem" view="cart"/><navigateTo navigateValue="fail" view="error" />
</node>
<node view="browsecatalog"><navigateTo navigateValue="addItem" view="cart"/><navigateTo navigateValue="fail" view="error" />
</node>
Vermont .NET56 - 65
UIP In Your Application
ControllerBaseControllerBase
Your Controller ClassYour Controller Class
DALCDALCDALCDALC
WinFormViewWinFormView
Your Windows FormsYour Windows Forms
WinFormViewWinFormView
Your Windows FormsYour Windows Forms
WebFormViewWebFormView
Your ASP.NET Pages or Windows Form,sYour ASP.NET Pages or Windows Form,s
WebFormViewWebFormView
Your ASP.NET Pages or Windows Form,sYour ASP.NET Pages or Windows Form,s
Biz Components
Biz Components
Biz ComponentsBiz Components
Data AccessData
Access
State Persistence ProviderState Persistence Provider
MyFunc(){ //do cool code //more good stuff}
MyFunc(){ //do cool code //more good stuff}
Persistence Providers: - SQL Server- Encrypted SQL Server - Memory - ASP.NET Session- Custom
State Persistence ProviderState Persistence ProviderState
Persistence Provider
State Persistence Provider
UIP ManagerUIP Manager
Application XML Configuration File
UIP Configuration UIP Configuration
View Managers:- Windows Forms- Web Pages
View ManagerView ManagerView ManagerView Manager
View ManagerView Manager
WebFormViewWebFormView
Your ASP.NET PagesYour ASP.NET Pages
WinFormViewWinFormView
Your Windows FormsYour Windows Forms
StateState
Your State Type(Optional)Your State Type(Optional)
Vermont .NET57 - 65
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
Vermont .NET58 - 65
demodemo
User Interface Process Block
Vermont .NET59 - 65
Configuration Management AB
• Secure configuration in multiple sources• Helps maintain application configuration• Pluggable Storage• Pluggable Signing & Encryption• Caching of config data for performance
Vermont .NET60 - 65
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>
Vermont .NET61 - 65
Configuration Mgmt Design
YourApplication
YourApplication
Application XML Configuration File (holds config for config)
Configuration Storage Configuration Storage Providers: Providers: - XML File- XML File- SQL Server- SQL Server- Registry- Registry- Custom- Custom
Configuration ManagerConfiguration Manager
Configuration Storage ProviderConfiguration Storage Provider
Data ProtectionProviderData ProtectionProvider
Data Protection Providers: Data Protection Providers: - DPAPI- DPAPI- BCL- BCL- Custom- Custom
Caching ServiceCaching Service
Configuration Section Handlers
Configuration Section HandlersConfiguration Section
HandlersConfiguration Section
HandlersConfiguration Section
Handlers
Configuration Section
Handlers
Data ProtectionProviderData ProtectionProviderData
ProtectionProvider
Data ProtectionProvider
Configuration Storage ProviderConfiguration Storage Provider
Configuration Storage ProviderConfiguration Storage Provider
Vermont .NET62 - 65
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
Vermont .NET63 - 65
Using the Updater AB
Update Controller(Application or separate EXE)
Update Controller(Application or separate EXE)
Updater Application Block
Updater Application Block
Application Update
Manifest
11
ServerClient
DownloaderDownloader
22
Application
Poll & Download
Controller XML Configuration File
File Copy
Administrator uses Manifest Utility
ValidatorValidator
Post Processor (optional)Post Processor (optional)
55
DownloaderDownloaderDownloaderDownloader
ValidatorValidator
44
33
Vermont .NET64 - 65
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
Vermont .NET65 - 65
Summary
•Where are we in the cycle?
•Where do you fit in?•Where should you make
your investment?
Vermont .NET66 - 65
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)
Vermont .NET67 - 65
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
Vermont .NET68 - 65
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
Vermont .NET69 - 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• Distributed LOB app design using Application Blocks