Architecture & design review check list)

ArticleDirectory

• Deployment and infrastructure deployment and infrastructure
• Coupling and cohesion coupling and cohesion
• Communication communication
• Concurrent concurrency
• Resource management
• Cache caching
• State management
• Data Structure and Algorithms
• Data Access
• Exception Handling
• Class Design Considerations
• DESIGN: Designing for Reliability
• Test testing for Reliability
• Design for availability
• Test testing for availability
• DESIGN: Designing for manageability
• Test testing for manageability

• Performance and scalability)
• Reliability)
• Availability)
• Manageability)

1. Performance and scalability)

• Deployment and infrastructure deployment and infrastructure
  • Make Rational Use of distributed architecture, and introduce distributed architecture only when necessary
    Use distributed ubuntures appropriately. Do not introduce distribution unnecessarily.

  • Exercise caution when selecting an appropriate distributed Communication Mechanism
    Carefully select appropriate distributed communication mechanisms.

  • Place frequently-interacted components within the same boundary as much as possible or as close as possible (proximity principle)
    Locate components that interact frequently within the same boundary or as close to each other as possible.

  • In the design, the limitations of the infrastructure are taken into account.
    Take infrastructure restrictions into account in your design.

  • Network bandwidth restrictions
    Consider network bandwidth restrictions.

  • Define resource limits
    Identify resource restrictions.

  • Make sure that your design does not restrict vertical scaling
    Ensure your design does not prevent you from scaling up.

  • Use a design that supports horizontal scaling and logical layering to avoid unintentional attachment relationships and enable Server Load balancer
    Ensure your design does not prevent you from scaling out and it uses logical layers, does not unwittingly introduce affinity, and supports load balancing.

• Coupling and cohesion coupling and cohesion

  • Make sure that your design is loosely coupled
    Ensure your design is loosely coupled.

  • Embody moderate cohesion in your design and group relevant entities, such as classes and Methods
    Exhibit appropriate degrees of cohesion in your design and group together logically related entities, such as classes and methods.

  • Use post-binding (such as reflection) if necessary.
    Restrict use of late binding and only use late binding where it is necessary and appropriate.

• Communication communication

  • avoid excessive interface sessions (that is, avoid too small-granularity communication interfaces)
    interfaces do not enforce chatty communication.

  • make sure that the Program of your application is called remotely only where necessary; minimize the impact of client verification, client cache, and batch jobs
    ensure your application only makes remote CILS where necessary. impact is minimized by client-side validation, client-side caching, and batching of work.

  • optimized Remote Data Exchange (such as data compression and serialization)
    optimize remote data exchange.

  • select an appropriate communication encryption mechanism
    choose appropriate secure communication mechanisms.

  • Use message queue to decouple all components of your system
    Use message queues to decouple component parts of your system.

  • use a message queue, fire-And forget method and Asynchronous Method call, reduce the impact of long-running calls
    mitigate the impact of long-running callby using message queues, "fire-And forget" approaches, and Asynchronous Method CILS.

  • do not use processes when the application domain is more suitable
    do not use processes where application domains are more appropriate.

• Concurrent concurrency

  • Do not create a thread for each request in your program. Use the thread pool provided by Clr and Win32 instead.
    In your application do not create threads on a per-request basis, and use the Common Language Runtime (CLR) thread pool and Win32 thread pool instead.

  • Set only the types that must be thread-safe to thread-safe.
    Only types that need to be thread-safe are made thread-safe.

  • Careful consideration of lock Granularity
    Carefully consider lock granularity.

  • Ensure that your program gets resources and locks as late as possible, release them as early as possible, and thus reduce the possibility of conflict
    Ensure your application acquires shared resources and locks late and releases them early to reduce contention.

  • Select an appropriate synchronization Element
    Choose appropriate synchronization primitives.

  • Select an appropriate transaction isolation level
    Choose an appropriate transaction isolation level.

  • Make sure that I/O intensive tasks are executed asynchronously, but do not need to be executed asynchronously for CPU intensive tasks.
    Ensure your application uses asynchronous execution for I/O bound tasks and not for CPU bound tasks.

• Resource management
• Ensure that your design supports and efficiently utilizes various "pool technologies"
  Ensure your design supports and makes valid tive use of pooling.
• Make sure that your program obtains and releases resources as late as possible, that is, releasing resources early.
  Ensure your application acquires resources late and releases them early.
• Cache caching

• Use cache for costly data (such as data acquisition, complex operations, and rendering)
  Use caching for data that is expensive to retrieve, compute, and render.

• Cache appropriate data, such as static pages, specific items of output data, stored procedure parameters, and query results.
  Cache appropriate data such as relatively static Web pages, specific items of output data, stored procedure parameters, and query results.

• Do not cache unstable data.
  Do not use caching for data that is too volatile.

• Select a reasonable cache location
  Select an appropriate cache location.

• Select a reasonable cache expiration Policy
  Select an appropriate cache expiration policy.

• State management
• Your design should use stateless components as much as possible, unless you have carefully considered the negative impact on scalability before deciding to use stateful Components
  Your design favors stateless components. Or, you considered the negative impact on scalability if you decided to use stateful components.

• If you use. Net remoting and need to support Server Load balancer, you need to use the single call server activation mode (SAO)
  If you use Microsoft. NET Framework remoting and need to support load balancing, you use single call server-activated objects (SAO ).

• If you use WebServices, you also need to use a message-based stateless mode.
  If you use web services, you also use a message-based stateless programming model.
• If you are using Enterprise Services, you also need to use stateless components to make them available in the object pool.
  If you use enterprise services, also use stateless components to facilitate object pooling.
• Objects that need to be put in the state storage must be serializable.
  Objects that you want to store in State stores support serialization.
• Consider the effect of viewstate on Performance
  Consider the performance impact of view State.
• Select a suitable session state storage mode based on the concurrency of the session and the amount of session data used by each user.
  Use statistics relating to the number of concurrent sessions and average session data per user to help choose an appropriate session State store.
• Data Structure andAlgorithmData Structure and Algorithms
• Make sure that your design uses the appropriate data structure
  Ensure your design uses appropriate data structures.
• As long as the user-defined set is used as a last resort
  Use custom collections only where absolutely necessary.
• If you need to implement your own set, implement the ienumerable interface.
  Extend the ienumerable interface for your collem collections.
• Data Access
• Use the most suitable data format when transferring data between layers, and seriously consider the impact of performance
  Pass data into ss the layers by using the most appropriate data format. carefully consider the performance implications.
• Use paremters (parameter set,. Net call SQL API) to call the parameter process for data access
  Use stored procedures with the Parameters collection for data access.
• Only process and pass the data you actually need
  Only process the data that is required.
• Provides a suitable data paging solution for query result sets with large data volumes
  Where appropriate, provide data paging solutions for large result sets.
• When the transaction context needs to span multiple components for transactions involving multiple resource managers, you can use declarative transactions of Enterprise Services to process them.

  Use Enterprise Services declarative transactions for transactions that span multiple resource managers or where you need to flow transaction context component SS components.

• If you want to control the Binary Large Object (blobs), use the appropriate chunking technology and do not move the same blob repeatedly.
  If you manipulate Binary large objects (blobs), use appropriate chunking techniques, and do not repeatedly move the same blob.
• Access duplicate dataCodePut them in the helper class.
  Specified lidate repeated data access code into helper classes.
• Exception Handling
• Do not use exceptions to control normal program logic Processes
  Do not use exceptions to control regular application flow.
• Use clear exception handling boundary (to prevent the spread of exception information)
  Use well-defined exception handling boundaries.
• Structured exception handling is a better error handling mechanism. Do not use error code for feedback.
  Structured exception handling is the preferred error handling mechanic. Do not rely on error codes.
• Only for specific reasons, and capture exceptions when you really need to capture them
  Only catch exceptions for a specific reason and when it is required.
• Class Design Considerations
• Class has the data they operate on
  Classes own the data that they act.
• Only use explicit interfaces when necessary. When you have some public functions interspersed with multiple classes, use explicit interfaces for polymorphism and versioning.
  Do not use explicit interfaces unnecessarily. Use explicit interfaces for versioning and for Polymorphism where you have common functionality implements SS multiple classes.
• Do not include virtual methods in the class unless you really need them.
  Classes do not contain virtual methods when they are not needed.
• It is better to use the overload method than the variable parameter method.
  Prefer overloaded methods to methods that take variable parameters.

2. Reliability)

• DESIGN: Designing for Reliability

• See the application development specifications for Windows Server 2003.
  Follow the application specification for Microsoft Windows Server 2003 http://www.microsoft.com/windowsserver2003/partners/isvs/appspec.mspx

• Include reliability requirements in development specifications
  Put reliability requirements into the specification.

• Good infrastructure usage
  Use of Good Practice tural infrastructure

• Add the management information to the application.
  Built management information into the application

• Use redundancy to improve reliability
  Use redundancy for Reliability

• Use built-in application Health Check
  Use built-in application health checks

• Reliable error handling
  Use consistent error handling

• Test testing for Reliability

• Use component stress testing
  Use component stress testing

• Use integrated stress testing
  Use integration stress testing

• Test with the actual environment
  Use real-world testing

• Test with random destruction
  Use random destruction Testing

3. Availability)

• Design for availability

• Reduces unplanned downtime by using Clusters
  Reduce unplanned downtime with Clustering

• Use Network Load Balancing
  Use Network Load Balancing

• Data Storage Using raid Disk Arrays
  Use raid for data stores

• Reduce planned downtime
  Reduce planned downtime

• Isolate dangerous applications
  Isolate mission critical applications

• Queue
  Use queuing

• Use a Distributed File System (DFS)
  Use distributed files system (DFS)

• Test testing for availability

• Change Control Process Test
  Test the change control process

• Catastrophic failure test
  Test catastrophic failure

• Test failover Technology
  Test the Failover Technologies

• Test Monitoring Technology
  Test the Monitoring Technology

• Test the Help Desk Process
  Test the help desk procedures

• Resource Conflict Test
  Test for resource conflicts

4. manageability)

• DESIGN: Designing for manageability

• Use the logging framework of the Enterprise Library in applications to improve manageability
  Use Enterprise Library logging framework in application to support manageability

• Use WMI
  Use Windows Management Instrumentation

• Use the SMS Server
  Use Systems Management Server

• Performance monitoring
  Use Performance Monitor

• Use the system preparation tool (sysprep. EXE)
  Use System Preparation Tool

• Use SNMP Network Monitoring Protocol
  Uses SNMP

• Use http monitoring tools
  Use http Monitoring Tool

• Use MS web compatibility analysis tools
  Use MS web capacity analysis tool

• Test testing for manageability

• Test WMI
  Test WMI

• Test cluster configuration
  Test cluster configuration

• Test network load balancing
  Test network load balancing

• Test Application Synchronization
  Test Application Synchronization