huge boobs pictures hd. 3gp desi glamcore perfect goddesses in oral.

https://eporner.monster destiny blonde has a sweet teen pussy.

Kỹ thuật

ADM and the Zachman Framework


Introduction | The Zachman Framework | Mapping TOGAF to the Zachman Framework


This chapter provides a mapping of the TOGAF Architecture Development Method (ADM) to the Zachman Framework.

Introduction

A number of architecture frameworks exist, each of which has its particular advantages and disadvantages, and relevance, for enterprise architecture. Several are discussed in Other Architectures and Frameworks .

However, there is no accepted industry standard method for developing an enterprise architecture. The Open Group goal with TOGAF is to work towards making the TOGAF ADM just such an industry standard method, which can be used for developing the products associated with any recognized enterprise framework that the architect feels is appropriate for a particular architecture. The Open Group vision for TOGAF is as a vehicle and repository for practical, experience-based information on how to go about the process of enterprise architecture, providing a generic method with which specific sets of deliverables, specific reference models, and other relevant architectural assets can be integrated.

To illustrate the concept, this section provides a mapping of the various phases of the TOGAF ADM to the cells of the well-known Zachman Framework.

The Zachman Framework

The Zachman Framework for Enterprise Architecture, sometimes simply referred to as the “Zachman Framework”, has become a de facto standard for classifying the artifacts developed in enterprise architecture. It is a logical structure for classifying and organizing the design artifacts of an enterprise that are significant to its management. It draws on a classification scheme found in the more mature disciplines of architecture/construction and engineering/manufacturing, used for classifying and organizing the design artefacts relating to complex physical products such as a building or an aircraft. Zachman adopts this classification scheme to the design and construction of information systems.

The Zachman Framework comprises a 6×6 matrix.


The columns represent various aspects of the enterprise that can be described or modeled; and the rows represent various viewpoints from which the aspects can be described. Thus each cell formed by the intersection of a column and a row represents an aspect of the enterprise modeled from a particular viewpoint. The architect selects and models the cells that are appropriate to the immediate purpose, with the ultimate objective of modeling all the cells.

The six viewpoints are:

  1. The Scope (Contextual) viewpoint – aimed at the planner
  2. The Business Model (Conceptual) viewpoint – aimed at the owner
  3. The System (Logical) viewpoint – aimed at the designer
  4. The Technology (Physical) viewpoint – aimed at the builder
  5. The Detailed Representations (Out-of-Context) viewpoint – aimed at the subcontractor
  6. The Functioning Enterprise viewpoint

The six aspects – and the interrogatives to which they correspond – are:

  1. The Data aspect – What?
  2. The Function aspect – How?
  3. The Network aspect – Where?
  4. The People aspect – Who?
  5. The Time aspect – When?
  6. The Motivation aspect – Why?

Although the Zachman Framework applies to enterprises, the Framework itself is generic. It is a comprehensive, logical structure for the descriptive representations (i.e., models or design artefacts) of any complex object, and it does not prescribe or describe any particular method, representation technique, or automated tool.

The strength of the Framework is that it provides a way of thinking about an enterprise in an organized way, so that it can be described and analyzed. It also enables the individuals involved in producing enterprise information systems to focus on selected aspects of the system without losing sight of the overall enterprise context. In designing and building complex systems, such as enterprise systems, there are simply too many details and relationships to consider simultaneously. At the same time, isolating single variables and making design decisions out of context results in sub-optimization, with all the attendant costs and risks. The challenge is the same whether the system is physical (like an aircraft) or conceptual (like an enterprise system). How do you design and build it, piece by piece, and step by step, such that it achieves its purpose without losing its value and raising its cost by optimizing the pieces and sub-optimizing the overall?

Mapping TOGAF to the Zachman Framework

The scope of the four architecture domains of TOGAF align very well with the first four rows of the Zachman Framework, as shown in the following mapping of these domains.


Several domains overlap in the above diagram: the earliest domain to address a cell has precedence in the coloring scheme.

The mappings of the individual phases of the ADM are shown in detail below.

Note:
In addition to the mappings to specific cells given below, the detailed representations and functioning enterprise viewpoints (the lowest two rows) of the Zachman Framework are also addressed and represented in TOGAF, through the Architecture Governance Framework (see Architecture Governance Framework), and through ADM deliverables such as the various Architecture Contracts (see Architecture Contracts). These ensure the validity and viability of the delivered solutions to meet the business needs.

Preliminary Phase: Framework and Principles

The outputs of this phase are:

  • Framework DefinitionZF: Business/Function (model of the architecture development process)
    [R2,C2]
  • Architecture principlesZF: Scope/Data, Scope/Function, Scope/Network, Scope/People, Scope/Time, Scope/Motivation
    [R1,C1; R1,C2; R1,C3; R1,C4; R1,C5; R1,C6]
  • Restatement of, or reference to, business principles, business goals, and business driversZF: Composite of: Scope/Motivation, Business/Motivation
    [R1,C6; R2,C6]

Phase A: Architecture Vision

The outputs of this phase are:

  • Approved Statement of Architecture Work, including in particular:
    • Scope and constraintsZF: Scope/Data, Scope/Function, Scope/Network, Scope/People, Scope/Time
      [R1,C1; R1,C2; R1,C3; R1,C4; R1,C5; R1,C6]
      Note:
      The Scope/Motivation cell is presumed to be addressed by strategic business planning activities outside the scope of the Architecture Vision.
    • Plan for the architecture work
  • Refined statements of business principles, business goals, and strategic driversZF: Scope/Data, Scope/Motivation
    [R1,C1; R1,C6]
  • Architecture principles (if not previously existing)ZF: Scope/Data, Scope/Function, Scope/Network, Scope/People, Scope/Time, Scope/Motivation
    [R1,C1; R1,C2; R1,C3; R1,C4; R1,C5; R1,C6]
  • Architecture Vision/Business Scenario, including:
    • Baseline Business Architecture, Version 0.1ZF: Business/Data, Business/Function, Business/Network, Business/People, Business/Time, Business/Motivation
      [R2,C2; R2,C2; R2,C3; R2,C4; R2,C5; R2,C6]
    • Baseline Technology Architecture, Version 0.1ZF: System/Data, System/Function, System/Network, System/People, System/Time, System/Motivation
      [R3,C2; R3,C2; R3,C3; R3,C4; R3,C5; R3,C6]
    • Target Business Architecture, Version 0.1ZF: Business/Data, Business/Function, Business/Network, Business/People, Business/Time, Business/Motivation
      [R2,C2; R2,C2; R2,C3; R2,C4; R2,C5; R2,C6]
    • Target Technology Architecture, Version 0.1ZF: System/Data, System/Function, System/Network, System/People, System/Time, System/Motivation
      [R3,C2; R3,C2; R3,C3; R3,C4; R3,C5; R3,C6]

Phase B: Business Architecture

The outputs of this phase are:

  • Statement of Architecture Work (updated if necessary)
  • Validated business principles, business goals, and strategic driversZF: Scope/Data, Scope/Function, Scope/Network, Scope/People, Scope/Time
    [R1,C1; R1,C2; R1,C3; R1,C4; R1,C5; R1,C6]
  • Target Business Architecture, Version 1.0 (detailed)
    • Organization structure, identifying business locations and relating them to organizational unitsZF: Scope/Network, Scope/People, Business/Network, Business/People
      [R1,C3; R1,C4; R2,C3; R2,C4]
    • Business goals and objectives, for each organizational unitZF: Scope/Network, Scope/Time, Business/Network, Business/Time, Business/Motivation
      [R1,C3; R1,C5; R2,C3; R2,C5; R2,C6]
      Note:
      The Scope/Motivation cell is presumed to be addressed by strategic business planning activities outside the scope of the Business Architecture.
    • Business functions – a detailed, recursive step involving successive decomposition of major functional areas into sub-functionsZF: Scope/Function, Business/Function
      [R1,C2; R2,C2]
    • Business services – the services that each enterprise unit provides to its customers, both internally and externallyZF: Business/Function, System/Function
      [R2,C2; R3,C2]
    • Business processes, including measures and deliverablesZF: Business/Function, Business/Time
      [R2,C2; R2,C5]
    • Business roles, including development and modification of skills requirementsZF: Scope/People, Business/People
      [R1,C4; R2,C4]
    • Correlation of organization and functions; relate business functions to organizational units in the form of a matrix reportZF: Scope/Function, Scope/Network, Scope/People, Business/Function, Business/Network, Business/People
      [R1,C2; R1,C3; R1,C4; R2,C2; R2,C3; R2,C4]
  • Baseline Business Architecture, Version 1.0 (detailed), if appropriate
  • Views corresponding to the selected viewpoints addressing key stakeholder concerns
  • Gap analysis results
  • Technical requirements (drivers for the Technology Architecture work): identifying, categorizing, and prioritizing the implications for work in the remaining architecture domains; for example, by a dependency/priority matrix (e.g., guiding trade-off between speed of transaction processing and security); list the specific models that are expected to be produced (e.g., expressed as primitives of the Zachman Framework)ZF: System/Motivation
    [R3,C6]
  • Business Architecture Report
  • Updated business requirements

Note:
The Business/Data cell is covered by the Data and Applications Architectures.

Phase C: Informations System Architectures: Data Architecture

The outputs of this part of Phase C are:

  • Statement of Architecture Work (updated if necessary)
  • Baseline Data Architecture, Version 1.0, if appropriate
  • Validated principles, or new data principles (if generated here)ZF: Scope/Data, Scope/Network, Scope/People, Scope/Time
    [R1,C3; R1,C4; R1,C5]
  • Target Data Architecture, Version 1.0:
    • Business data modelZF: Business/Data
      [R2,C1]
    • Logical data modelZF: System/Data
      [R3,C1]
    • Data management process modelsZF: System/Function, System/People
      [R3,C2; R3,C3]
    • Data entity/business function matrixZF: Composite of Business/People, System/Data, System/Function
      [R2,C4; R3,C1; R3,C2]
    • Data interoperability requirementsZF: Composite of System/Data, System/Function, System/Network, System/People
      [R3,C1; R3,C2; R3,C3; R3,C4]
  • Viewpoints addressing key stakeholder concerns
  • Views corresponding to the selected viewpoints; for example:
    • Data dissemination viewZF: Composite of System/Data, System/Function, System/Network, System/People
      [R3,C1; R3,C2; R3,C3; R3,C4]
    • Data lifecycle viewZF: Composite of System/Data, System/Function, System/Time
    • Data security viewZF: Composite of System/Function, System/Data, System/Network, System/People, System/Time
    • Data model management viewZF: Composite of Business/Data, System/Data, Business/Time, System/Time
  • Gap analysis results
  • Relevant technical requirements that will apply to this evolution of the architecture development cycleZF: System/Motivation
  • Data Architecture Report, summarizing what was done and the key findings
  • Impact Analysis
  • Updated business requirements, if appropriate

Phase C: Informations System Architectures: Applications Architecture

The outputs of this part of Phase C are:

  • Statement of Architecture Work (updated if necessary)
  • Baseline Applications Architecture, Version 1.0, if appropriate
  • Validated application principles, or new application principles (if generated here)ZF: Scope/Function, Scope/Network, Scope/People, Scope/Time
  • Target Applications Architecture, Version 1.0:
    • Process systems modelZF: System/Function
    • Systems/place modelZF: System/Network
    • People/systems modelZF: System/People
    • Systems/time modelZF: System/Time
    • Applications interoperability requirementsZF: Composite of System/Data, System/Function, System/Network, System/People, System/Time, System/Motivation
  • Viewpoints addressing key stakeholder concerns
  • Views corresponding to the selected viewpoints; for example:
    • Common applications services viewZF: Composite of System/Data, System/Function, System/Network, System/People, System/Time
    • Applications interoperability viewZF: Composite of System/Data, System/Function, System/Network, System/Time
    • Applications/information viewZF: Composite of System/Data, System/Function, System/Network, System/Time
    • Applications/user locations viewZF: Composite of System/Network, System/People
  • Gap analysis results
    • Areas where the Business Architecture may need to change to cater for changes in the Applications ArchitectureZF: Composite of Business/Data, Business/Function, Business/Network, Business/People, Business/Time
    • Identify any areas where the Data Architecture (if generated at this point) may need to change to cater for changes in the Applications ArchitectureZF: Composite of Business/Data, Business/People, Business/Time
    • Identify any constraints on the Technology Architecture about to be designedZF: System/Motivation
  • Applications Architecture Report, summarizing what was done and the key findings
  • Impact Analysis
  • Updated business requirements, if appropriate

Phase D: Technology Architecture

The outputs of Phase D are given below, first by relevant individual step, and then as a composite for the whole phase.

Step 1: Create a Baseline Description in the TOGAF Format

The outputs of this step are:

  • Technology Architecture principles (if not existing)ZF: Scope/Data, Scope/Function, Scope/Network, Scope/People, Scope/Time, Scope/Motivation
  • Target Technology Architecture, Version 0.2:
    • Technology Architecture – Constraints
    • Technology Architecture – Architecture Principles
    • Technology Architecture – Requirements Traceability, key questions list
    • Technology Architecture – Requirements Traceability, criteria for selection of service portfolio
    • Technology Architecture Model, Version 0.1ZF: Technology/Function, Technology/Network

Step 2: Consider Different Architecture Reference Models, Viewpoints, and Tools

The outputs of this step are:

  • Target Technology Architecture, Version 0.3
    • Technology Architecture – Architecture Viewpoints
      • Networked computing/hardware viewZF: System/Network, Technology/Network
      • Communications viewZF: Composite of: System/Network, System/People, Technology/Network, Technology/People
      • Processing viewZF: System/Data, System/Function, System/Network, System/People, System/Time, Technology/Data, Technology/Function, Technology/Network, Technology/People, Technology/Time
      • Cost viewZF: Technology/Motivation
      • Standards viewZF: Technology/Motivation
    • Technology Architecture – ConstraintsZF: System/Motivation

Step 3: Create an Architectural Model of Building Blocks

The outputs of this step are:

  • Target Technology Architecture, Version 0.4
    • Technology Architecture Model
      • Networked computing/hardware viewZF: Technology/Network, System/Network
      • Communications viewZF: Composite of: Technology/Network, Technology/People, System/Network, System/People
      • Processing viewZF: Technology/Network, Technology/Time, Technology/People, Technology/Data, Technology/Function, System/Network, System/Time, System/People, System/Data, System/Function
      • Cost viewZF: Technology/Motivation
      • Standards viewZF: Technology/Motivation
    • Technology Architecture – change requests and/or extensions or amendments to be incorporated in an organization-specific Architecture Continuum

Step 4: Select the Services Portfolio Required per Building Block

The outputs of this step are:

  • Target Technology Architecture, Version 0.5
    • Technology Architecture – target services (a description of the service portfolios required also known as an Organization-Specific Framework)ZF: Technology/Network, Technology/Time, Technology/People, Technology/Data, Technology/Function, Technology/Motivation
    • Technology Architecture – change requests and/or extensions or amendments to be incorporated in an organization-specific Architecture Continuum

Step 8: Conduct a Gap Analysis

The outputs of this step are:

  • Target Technology Architecture, Version 1.0:
    • Technology Architecture – gap reportZF: Composite of Technology/Data, Technology/ Function, Technology/Network, Technology/People, Technology/Time, Technology/Motivation

Composite Mapping for Phase D


For more detailed information on the Zachman Framework, refer to any of John Zachman’s publications, or the Zachman Institute for Framework Advancement (ZIFA) (www.zifa.com).
return to top of page


Navigation

The TOGAF document set is designed for use with frames. To navigate around the document:

  • In the main Contents frame at the top of the page, click the relevant hyperlink (Part I, Part II, etc.) to load the Contents List for that Part of the TOGAF document into the Secondary Index frame in the left margin.
  • Then click in that Contents List to load a page into this main frame.

return to top of page


Downloads

Downloads of the TOGAF documentation, are available under license from the TOGAF information web site. The license is free to any organization wishing to use TOGAF entirely for internal purposes (for example, to develop an information system architecture for use within that organization). A hardcopy book is also available from The Open Group Bookstore as document G063.

Using SOAP Headers

Using SOAP Headers

.NET Framework 1.1

Communicating with an XML Web service method using SOAP follows a standard format. Part of this format is the data that is encoded in an XML document. The XML document consists of a root Envelope tag, which in turn consists of a required Body element and an optional Header element. The Body element comprises the data specific to the message. The optional Header element can contain additional information not directly related to the particular message. Each child element of the Header element is called a SOAP header.

Although the SOAP headers can contain data related to the message, as the SOAP specification doesn’t strictly define the contents of a SOAP header, they typically contain information processed by infrastructure within a Web server. An example of how a SOAP header can be used is to supply routing information for the SOAP message within the SOAP header.

Defining and Processing SOAP Headers

XML Web services created using ASP.NET can define and manipulate SOAP headers. Defining a SOAP header is accomplished by defining a class representing the data in a particular SOAP header and deriving it from the SoapHeader class.

To define a class representing a SOAP header

  1. Create a class deriving from the SoapHeaderclass with a name matching the root element for the SOAP header.
    public class MyHeader : SoapHeader
    [Visual Basic]
    Public Class MyHeader : Inherits SoapHeader
  2. Add public fields or properties, matching the names and their respective data types for each element in the SOAP header.For instance, given the following SOAP header, the class following it defines a class representing the SOAP header.
    public class MyHeader : SoapHeader
    {
       public DateTime Created;
       public long Expires;
    }
    [Visual Basic]
    Public Class MyHeader
      Inherits SoapHeader
        Public Created As DateTime
        Public Expires As Long
    End Class

To process SOAP headers within an XML Web service

  1. Add a public member to the class implementing the XML Web service of the type representing the SOAP header.
    [WebService(Namespace="http://www.contoso.com")]
    public class MyWebService
    {
        // Add a member variable of the type deriving from SoapHeader.
        public MyHeader timeStamp;
    [Visual Basic]
    <WebService(Namespace:="http://www.contoso.com")> _
    Public Class MyWebService
        ' Add a member variable of the type deriving from SoapHeader.
        Public TimeStamp As MyHeader
  2. Apply a SoapHeader attribute to each XML Web service method that intends to process the SOAP header. Set the MemberName property of the SoapHeaderattribute to the name of the member variable created in the first step.
    [WebMethod]
    [SoapHeader("timeStamp")]
    public void MyWebMethod()
    [Visual Basic]
    <WebMethod, SoapHeader("TimeStamp")> _
    Public Sub MyWebMethod()
  3. Within each XML Web service method that the SoapHeaderattribute is applied to, access the member variable created in the first step to process the data sent in the SOAP header.
    [WebMethod]
    [SoapHeader("timeStamp",
                Direction=SoapHeaderDirection.InOut)]
    public string MyWebMethod()
    {
      // Verify that the client sent the SOAP Header.
      if (timeStamp == null)
      {
         timeStamp = new MyHeader();
      }
      // Set the value of the SoapHeader returned
      // to the client.
      timeStamp.Expires = 60000;
      timeStamp.Created = DateTime.UtcNow;
    
      return "Hello World";
    }
    [Visual Basic]
    <WebMethod,SoapHeader("TimeStamp", _
                          Direction:=SoapHeaderDirection.InOut)> _
    Public Function MyWebMethod() As String
       ' Verify that the client sent the SOAP Header.
       If (TimeStamp Is Nothing) Then
          TimeStamp = New MyHeader
       End If
    
       ' Set the value of the SoapHeader returned
       ' to the client.
       TimeStamp.Expires = 60000
       TimeStamp.Created = DateTime.UtcNow
    
       Return "Hello World"
    End Function

The following code example demonstrates how to define and process a SOAP header in an XML Web service created using ASP.NET. The MyWebService XML Web service has a member variable named timeStamp, which is of a type deriving from SoapHeader (MyHeader) and set to the MemberName property of the SoapHeader attribute. In addition, a SoapHeader attribute is applied to the MyWebMethod XML Web service method specifying myHeaderMemberVariable. Within the MyWebMethod XML Web service method, myHeaderMemberVariable is accessed to set the value of the Created and Expires XML elements of the SOAP header.

<%@ WebService Language="C#" Class="MyWebService" %>
using System;
using System.Web.Services;
using System.Web.Services.Protocols;

// Define a SOAP header by deriving from the SoapHeader class.
public class MyHeader : SoapHeader
{
   public DateTime Created;
   public long Expires;
}

[WebService(Namespace="http://www.contoso.com")]
public class MyWebService : System.Web.Services.WebService
{
   // Add a member variable of the type deriving from SoapHeader.
   public MyHeader timeStamp;

   // Apply a SoapHeader attribute.
   [WebMethod]
   [SoapHeader("timeStamp", Direction=SoapHeaderDirection.InOut)]
   public string HelloWorld()
   {
      if (timeStamp == null)
         timeStamp = new MyHeader();

      timeStamp.Expires = 60000;
      timeStamp.Created = DateTime.UtcNow;

      return "Hello World";
   }
}
[Visual Basic]
<%@ WebService Language="VB" Class="MyWebService" %>
Imports System
Imports System.Web.Services
Imports System.Web.Services.Protocols

' Define a SOAP header by deriving from the SoapHeader class.
Public Class MyHeader
    Inherits SoapHeader
    Public Created As DateTime
    Public Expires As Long
End Class

<WebService(Namespace:="http://www.contoso.com")> _
Public Class MyWebService
    Inherits System.Web.Services.WebService

    ' Add a member variable of the type deriving from SoapHeader.
    Public timeStamp As MyHeader

    ' Apply a SoapHeader attribute.
    <WebMethod(), _
     SoapHeader("timeStamp", Direction:=SoapHeaderDirection.InOut)> _
    Public Function HelloWorld() As String

        If (timeStamp Is Nothing) Then
            timeStamp = New MyHeader
        End If

        timeStamp.Expires = 60000
        timeStamp.Created = DateTime.UtcNow

        Return "Hello World"
    End Function
End Class

In the previous example, a SOAP response is returned to the client with the Expires element set to 60000 (number of milliseconds, so 1 minute) and the Created element to the current time in coordinated universal time. That is, the following SOAP response is sent to the client.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Header>
    <MyHeader xmlns="http://www.contoso.com">
      <Created>dateTime</Created>
      <Expires>long</Expires>
    </MyHeader>
  </soap:Header>
  <soap:Body>
    <MyWebMethod xmlns="http://www.contoso.com" />
  </soap:Body>
</soap:Envelope>

Building a Client that Processes SOAP Headers

An XML Web services client can send and receive SOAP headers when communicating with an XML Web service. When a proxy class is generated for an XML Web service expecting or returning SOAP headers using the Wsdl.exe utility, the proxy class includes information about the SOAP headers. Specifically, the proxy class has member variables representing the SOAP headers that correlate to those found in the XML Web service. The proxy class also has definitions for the corresponding classes representing the SOAP header. For example, proxy classes generated for the previous XML Web service will have a member variable of type MyHeader and a definition for the MyHeader class. For details on creating a proxy class, see Creating an XML Web Service Proxy.

Note: If the XML Web service defines the member variables representing the SOAP headers of type SoapHeader or SoapUnknownHeader instead of a class deriving from SoapHeader, a proxy class will not have any information about that SOAP header.

To process SOAP headers within an XML Web service client

  1. Create a new instance of the class representing the SOAP header.
    Dim mySoapHeader As MyHeader = New MyHeader()
    [C#]
    MyHeader mySoapHeader = new MyHeader();
  2. Populate the values for the SOAP header.
    header.Expires = 60000
    header.Created = DateTime.UtcNow
    [C#]
    header.Expires = 60000;
    header.Created = DateTime.UtcNow;
  3. Create a new instance of the proxy class.
    Dim proxy As MyWebService = New MyWebService()
    [C#]
    MyWebService proxy = new MyWebService();
  4. Assign the SOAP header object to the member variable of the proxy class representing the SOAP header.
    proxy.MyHeaderValue = mySoapHeader
    [C#]
    proxy.MyHeaderValue = mySoapHeader
  5. Call the method on the proxy class that communicates with the XML Web service method.The SOAP header portion of the SOAP request sent to the XML Web service will include the contents of the data stored in the SOAP header object.
    Dim results as String = proxy.MyWebMethod()
    [C#]
    string results = proxy.MyWebMethod();

The following code example demonstrates how to pass a SOAP header from a client to an XML Web service.

<%@ Page Language="VB" %>

<asp:Label id="ReturnValue" runat="server" />
<script runat=server language=VB>

 Sub Page_Load(o As Object, e As EventArgs)

  Dim header As MyHeader = New MyHeader()

  ' Populate the values of the SOAP header.
   header.Expires = 60000
   header.Created = DateTime.UtcNow

  ' Create a new instance of the proxy class.
  Dim proxy As MyWebService = New MyWebService()

  ' Add the MyHeader SOAP header to the SOAP request.
  proxy.MyHeaderValue = header

  ' Call the method on the proxy class that communicates
  ' with your XML Web service method.
  Dim results as String = proxy.MyWebMethod()

  ' Display the results of the method in a label.
  ReturnValue.Text = results

 End Sub
</script>
[C#]
<%@ Page Language="C#" %>

<asp:Label id="ReturnValue" runat="server" />
<script runat=server language=c#>

 void Page_Load(Object o, EventArgs e)
 {

  MyHeader header = new MyHeader();

  // Populate the values of the SOAP header.
  header.Expires = 60000;
  header.Created = DateTime.UtcNow;

  // Create a new instance of the proxy class.
  MyWebService proxy = new MyWebService();

  // Add the MyHeader SOAP header to the SOAP request.
  proxy.MyHeaderValue = header;

  // Call the method on the proxy class that communicates
  // with your XML Web service method.
  string results = proxy.MyWebMethod();

  // Display the results of the method in a label.
  ReturnValue.Text = results;
 }
</script>

Changing the SOAP Headers Recipients

By default, SOAP headers are sent by an XML Web service client to an XML Web service method when a SoapHeader attribute is applied to an XML Web service method. However, a SOAP header can also be sent by the XML Web service method back to the XML Web service client. It can also be sent both ways. Setting the Direction property of a SoapHeader attribute applied to an XML Web service method controls the recipient of the SOAP header. The Direction property is of type SoapHeaderDirection, which has four values: In, Out, InOut, and Fault. These refer to the recipient (whether it is the XML Web service server), to the client, or both the XML Web service server and client, and whether the SOAP header is sent to the client when an exception is thrown by the XML Web service, respectively.

Note: Version 1.0 of the .NET Framework SDK does not support the Fault value.

To change the SOAP header recipient

  1. Define the SOAP header.
    public class MyHeader : SoapHeader
    {
       public DateTime Created;
       public long Expires;
    }
    [Visual Basic]
    Public Class MyHeader
      Inherits SoapHeader
        Public Created As DateTime
        Public Expires As Long
    End Class
  2. Add a member variable to the class implementing the XML Web service.
    [WebService(Namespace="http://www.contoso.com")]
    public class MyWebService : WebService
    {
        public MyHeader myOutHeader;
    [Visual Basic]
    <WebService(Namespace:="http://www.contoso.com")> _
    Public Class MyWebService
      Inherits WebService
        Public myOutHeader As MyHeader
  3. Apply a SoapHeader attribute to each XML Web service method that processes the SOAP header. Set the Direction property to each intended recipient, using the SoapHeaderDirection enumeration. The following example sets the XML Web service client as the recipient by setting Direction to SoapHeaderDirection.Out.
        [WebMethod]
        [SoapHeader("myOutHeader",Direction=SoapHeaderDirection.Out)]
    [Visual Basic]
        <WebMethod, _
         SoapHeader("myOutHeader",Direction:=SoapHeaderDirection.Out)>
  4. Process or set the SOAP header, depending on the recipient. The following code example sets the values of the SOAP header, as the recipient is the XML Web service client.
    // Set the Time the SOAP message expires.
    myOutHeader.Expires = 60000;
    myOutHeader.Created = DateTime.UtcNow;
    [Visual Basic]
    ' Set the Time the SOAP message expires.
    myOutHeader.Expires = 60000
    myOutHeader.Created = DateTime.UtcNow

The following code example defines a MyHeader SOAP header that is sent from the XML Web service method to the client.

<%@ WebService Language="C#" Class="MyWebService" %>
using System;
using System.Web.Services;
using System.Web.Services.Protocols;

// Define a SOAP header by deriving from the SoapHeader class.
public class MyHeader : SoapHeader
{
   public DateTime Created;
   public long Expires;
} 

[WebService(Namespace="http://www.contoso.com")]
public class MyWebService : WebService
{
    public MyHeader myOutHeader;

    [WebMethod]
    [SoapHeader("myOutHeader",Direction=SoapHeaderDirection.Out)]
    public void MyOutHeaderMethod()
    {
      // Set the time the SOAP message expires.
      myOutHeader.Expires = 60000;
      myOutHeader.Created = DateTime.UtcNow;
    }
}
[Visual Basic]
<%@ WebService Language="VB" Class="MyWebService" %>
Imports System
Imports System.Web.Services
Imports System.Web.Services.Protocols

' Define a SOAP header by deriving from the SoapHeader class.
Public Class MyHeader
  Inherits SoapHeader
    Public Created As DateTime
    Public Expires As Long
End Class

<WebService(Namespace:="http://www.contoso.com")> _
Public Class MyWebService
  Inherits WebService
    Public myOutHeader As MyHeader 

    <WebMethod, _
     SoapHeader("myOutHeader",Direction:=SoapHeaderDirection.Out)> _
    Public Sub MyOutHeaderMethod()
         ' Set the time the SOAP message expires.
         myOutHeader.Expires = 60000
         myOutHeader.Created = DateTime.UtcNow
    End Sub
End Class

Handling Unknown SOAP Headers

An XML Web service client can send a SOAP request with a SOAP header to an XML Web service method that the XML Web service might not have explicitly defined that it was expecting. In this case, it is important to determine whether the semantics of the SOAP header are understood and processed, as the SOAP specification states that an exception is thrown when SOAP headers have a mustUnderstand attribute set to true. For details on handling SOAP headers required by a client, see Handling SOAP Headers Required by an XML Web Service Client.

To handle unknown SOAP headers from an XML Web service client

  1. Add a member variable to the class implementing the XML Web service with a type of SoapUnknownHeader or SoapHeader, or an array of either, to handle multiple unknown SOAP headers.Declaring the type as either an array or a single instance of SoapUnknownHeader has the added benefit that SoapUnknownHeader has an Element property. The Element property is of type XmlElement and represents the XML document for the Header element of the SOAP request or SOAP response. Thus, an XML Web service method can determine the name of the SOAP header, along with the data passed by the SOAP header, by interrogating the Elementproperty.
    public class MyWebService {
        public SoapUnknownHeader[] unknownHeaders;
    [Visual Basic]
    Public Class MyWebService
        Public unknownHeaders() As SoapUnknownHeader
  2. Apply a SoapHeader attribute to each XML Web service method that intends to process each unknown SOAP header.
        [WebMethod]
        [SoapHeader("unknownHeaders")]
        public string MyWebMethod()
    [Visual Basic]
        <WebMethod, _
         SoapHeader("unknownHeaders") > _
        Public Function MyWebMethod() As String
  3. Add code to determine whether you can process any unknown SOAP headers.If the member variable is of type SoapUnknownHeader, an XML Web service method can determine the name of the SOAP header, along with the data passed by the SOAP header, by interrogating the Element property. The Name property of Elementproperty identifies the name of the SOAP header.
           foreach (SoapUnknownHeader header in unknownHeaders)
           {
             // Check to see if this a known header.
             if (header.Element.Name == "MyKnownHeader")
    [Visual Basic]
           Dim header As SoapUnknownHeader
           For Each header In unknownHeaders
             ' Check to see if this is a known header.
             If (header.Element.Name = "MyKnownHeader") Then
  4. Set the DidUnderstand property of the member variable representing the unknown SOAP header to trueif it is known how to process a particular SOAP header.If an XML Web service method does process an unknown SOAP header and does not set the DidUnderstand property to true, a SoapHeaderException can be thrown. For more details, see Handling SOAP Headers Required by an XML Web Service Client
             // Check to see if this is a known header.
             if (header.Element.Name == "MyKnownHeader")
                   header.DidUnderstand = true;
             else
                 // For those headers that cannot be
                 // processed, set DidUnderstand to false.
                 header.DidUnderstand = false;
             }
    [Visual Basic]
             ' Check to see if this a known header.
             If (header.Element.Name = "MyKnownHeader") Then
                   header.DidUnderstand = True
             Else
                 ' For those headers that cannot be
                 ' processed, set DidUnderstand to false.
                 header.DidUnderstand = False
             End If

    Note   The DidUnderstand property is used by XML Web services created using ASP.NET to communicate with the XML Web service method. It is not part of the SOAP specification. Its value does not appear in any part of the SOAP request or SOAP response.

    Note   When an XML Web service client builds a proxy class using the Web Services Description Language Tool (Wsdl.exe) and an XML Web service defines the member variable representing a SOAP header using the SoapUnknownHeader type, no reference to that SOAP header is added to the proxy class. If an XML Web service client decides to add that SOAP header to the SOAP request, they must modify the proxy class by adding a member variable and applying a SoapHeader attribute to the method making the call to the pertinent XML Web service method.

Handling SOAP Headers Required by an XML Web Service Client

A client can require an XML Web service method to interpret the semantics of the SOAP header correctly and process it accordingly for the SOAP request to succeed. To do so, clients set the mustUnderstand attribute of the SOAP header to 1. For instance, the following SOAP request requires the SOAP request recipient to process the MyCustomSoapHeader SOAP header.

<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" >
  <soap:Header>
    <MyCustomSoapHeader soap:mustUnderstand="1" xmlns="http://www.contoso.com">
      <custom>Keith</custom>
    </MyCustomSoapHeader>
  </soap:Header>
  <soap:Body>
    <MyUnknownHeaders xmlns="http://www.contoso.com" />
  </soap:Body>
</soap:Envelope>

Whether the XML Web service defines the SOAP header or not determines how the XML Web service should handle SOAP headers required by the client. ASP.NET handles a lot of the work in the case where the XML Web service defines the SOAP header. In the procedure that follows, you can learn how to handle the two cases.

To handle SOAP headers not defined by the XML Web service, but required by an XML Web service client

  • Follow the steps for handling unknown SOAP headers from an XML Web service client, paying particular attention to the DidUnderstandproperty of the SOAP header.For SOAP headers not defined by the XML Web service, the initial value of DidUnderstand is false. If ASP.NET detects SOAP headers with their DidUnderstand property set to false after the XML Web service method returns, a SoapHeaderException is automatically thrown.

To handle SOAP headers required by an XML Web service client and defined by the XML Web service

  • Follow the steps for processing SOAP headers within an XML Web service created using ASP.NET within each XML Web service method.For SOAP headers defined by the XML Web service and processed in the XML Web service method receiving the SOAP header, ASP.NET assumes the XML Web service understands the SOAP header and sets the initial value of DidUnderstand to true.

The following MyWebService XML Web service defines the MyHeader SOAP header and requires it to be sent with any calls to the MyWebMethod XML Web service method. Additionally, the MyWebMethod processes any unknown SOAP headers. For the SOAP headers MyWebMethod can process, DidUnderstand is set to true.

<%@ WebService Language="C#" Class="MyWebService" %>
using System.Web.Services;
using System.Web.Services.Protocols;

// Define a SOAP header by deriving from the SoapHeader base class.
public class MyHeader : SoapHeader {
    public string MyValue;
}
public class MyWebService {
    public MyHeader myHeader;

    // Receive all SOAP headers other than the MyHeader SOAP header.
    public SoapUnknownHeader[] unknownHeaders;

    [WebMethod]
    [SoapHeader("myHeader")]
    //Receive any SOAP headers other than MyHeader.
    [SoapHeader("unknownHeaders")]
    public string MyWebMethod()
    {
       foreach (SoapUnknownHeader header in unknownHeaders)
       {
         // Perform some processing on the header.
         if (header.Element.Name == "MyKnownHeader")
               header.DidUnderstand = true;
         else
                // For those headers that cannot be
                // processed, set DidUnderstand to false.
                header.DidUnderstand = false;
       }
       return "Hello";
    }
}
[Visual Basic]
<%@ WebService Language="VB" Class="MyWebService" %>
Imports System.Web.Services
Imports System.Web.Services.Protocols

' Define a SOAP header by deriving from the SoapHeader base class.
Public Class MyHeader : Inherits SoapHeader
    Public MyValue As String
End Class

Public Class MyWebService
    Public myHeader As MyHeader

    ' Receive all SOAP headers other than the MyHeader SOAP header.
    Public unknownHeaders() As SoapUnknownHeader    

    <WebMethod, _
     SoapHeader("myHeader"), _
     SoapHeader("unknownHeaders")> _
    Public Function MyWebMethod() As String
        'Receive any SOAP headers other than MyHeader.
        Dim header As SoapUnknownHeader
        For Each header In unknownHeaders
            ' Perform some processing on the header.
            If header.Element.Name = "MyKnownHeader" Then
                header.DidUnderstand = True
            ' For those headers that cannot be
            ' processed, set DidUnderstand to false.
            Else
                header.DidUnderstand = False
            End If
        Next header
        Return "Hello"
    End Function
End Class

Note   The DidUnderstand property is used by ASP.NET to communicate with the XML Web service method. It is not part of the SOAP specification; its value does not appear in any part of the SOAP request or SOAP response.

If an XML Web service forwards a SOAP header, it is very important to follow the rules in the SOAP specification, especially those pertaining to the value of the Actor. For details, see the W3C Web site (http://www.w3.org/TR/SOAP/).

Handling Errors That Occur While Processing a SOAP Header

When an XML Web service detects an error specific to the processing of a header, a SoapHeaderException should be thrown. Using this exception class allows XML Web services to correctly format the response. If the client is created using the .NET Framework, it will receive the SoapHeaderException with its contents, including the InnerException property, placed in the Message property. The InnerException property of the SoapHeaderException caught by the client will be null. This is a programming model supported by the .NET Framework, as the exception is sent over the network in a SOAP <Fault> XML element, as prescribed by the SOAP specification. For more details on exceptions, see Handling and Throwing Exceptions in XML Web Services.

The following code example throws a SoapHeaderException if a client makes a SOAP request to the MyWebMethod XML Web service method setting the Expires property to a date and time that occurs in the past by the time the SOAP request reaches the XML Web service.

<%@ WebService Language="C#" Class="MyWebService" %>
using System.Web.Services;
using System.Web.Services.Protocols;

// Define a SOAP header by deriving from the SoapHeader class.
public class MyHeader : SoapHeader
{
  public DateTime Created;
  public DateTime Expires;
  public DateTime Received;
} 

[WebService(Namespace="http://www.contoso.com")]
public class MyWebService
{
    // Add a member variable of the type deriving from SoapHeader.
    public MyHeader myHeaderMemberVariable;

    // Apply a SoapHeader attribute.
    [WebMethod]
    [SoapHeader("myHeaderMemberVariable")]
    public void MyWebMethod()
    {
       if (timeStamp == null)
          timeStamp = new MyHeader();
       else
       {
          // Check whether the SOAP message is expired.
          if ((timeStamp.Expires.CompareTo(DateTime.UtcNow)) <= 0)
          {
             // The SOAP message is expired, so throw a SOAP header
             // exception indicating that.
             SoapHeaderException se = new SoapHeaderException(
               "SOAP message expired before reaching this node.",
               SoapException.ClientFaultCode,
               this.Context.Request.Url.ToString());
             throw se;
          }
       }
    }
}
[Visual Basic]
<%@ WebService Language="VB" Class="MyWebService" %>
Imports System.Web.Services
Imports System.Web.Services.Protocols

' Define a SOAP header by deriving from the SoapHeader class.
Public Class MyHeader
  Inherits SoapHeader
    Public Created As DateTime
    Public Expires As DateTime
    Public Received As DateTime
End Class

<WebService(Namespace:="http://www.contoso.com")> _
Public Class MyWebService
    ' Add a member variable of the type deriving from SoapHeader.
    Public myHeaderMemberVariable As MyHeader    

    ' Apply a SoapHeader attribute.
    <WebMethod, _
     SoapHeader("myHeaderMemberVariable")> _
    Public Sub MyWebMethod()
       If (TimeStamp Is Nothing) Then
          TimeStamp = New MyHeader
       Else
           ' Check whether the SOAP message is expired.
           If ((TimeStamp.Expires.CompareTo(DateTime.UtcNow)) <= 0) Then
             ' The SOAP message is expired, so throw a SOAP header
             ' exception indicating that.
             Dim se As New SoapHeaderException( _
                "SOAP message expired before reaching this node.", _
                SoapException.ClientFaultCode, _
                Me.Context.Request.Url.ToString())
             Throw se
           End If
       End If
    End Sub
End Class

Note: The .NET Framework version 1.0 includes the SoapHeaderAttribute.Required property which enables an XML Web service to require that a client send a specific SOAP header when the property is set to true. ASP.NET indicates that the SOAP header is required in a generated WSDL document by setting the wsdl:required attribute to “true” on the soap:header element. .NET Framework clients of the XML Web service built from the WSDL document receive a SoapHeaderException if they do not send the required SOAP header and other clients receive a SOAP Fault. To interoperate with other SOAP implementations this functionality is removed in later versions.

The Required property is obsolete in version 1.1, and the wsdl:required attribute of a soap:header element in a WSDL document is ignored by the Web Services Description Language tool (Wsdl.exe). Because a SOAP header can no longer be required, an XML Web service should verify that the field or property representing the SOAP header is not null before accessing it.

See Also

SoapHeader | SoapHeaderAttribute | SoapHeaderException | SoapUnknownHeader | Building XML Web Services Using ASP.NET | Building XML Web Service Clients

Kiến trúc tổng thể: Bức tranh toàn cảnh

Nguyễn Tuấn Hoa (www.pcworld.com.vn)
Phải xây dựng được thứ có thể nhìn thấu mọi thứ. Phải thực hiện kiến trúc chính phủ điện tử (CPĐT), trong một môi trường phối cảnh đa chiều để cân nhắc xem chúng gắn kết, tương tác với nhau như thế nào? Làm thế nào để có thể đi từ trạng thái hiện thời đến trạng thái đích…? Phương pháp luận về CPĐT gọi bức tranh đó là kiến trúc tổng thể (Enterprise Architecture, gọi tắt là EA).
 

Mọi tổ chức đều vận động dựa trên thông tin. Theo đó, những con người hay nhóm – thành phần cấu tạo tổ chức – đảm đương những nhiệm vụ cụ thể luôn luôn giao tiếp với nhau, thông tin cho nhau để tương tác giữa bộ phận này với bộ phận khác, người này với người khác… Chỉ như thế, tổ chức mới có thể tồn tại và phát triển.

Trong khi đó, tổ chức lại xuất hiện từ xa xưa, trước CNTT rất lâu. Và từ thời xa xưa ấy, bản chất trên đã tồn tại và sẽ tồn tại mãi mãi cùng với xã hội loài người. Vì thế, việc mô hình hóa tổ chức luôn luôn dẫn đến bộ đôi: Mô hình tổ chức (tổ chức được cấu trúc như thế nào?) và mô hình thông tin (hệ thống thông tin bên trong tổ chức được xây dựng và vận hành như thế nào?).

Mọi chuyện thay đổi khi CNTT ra đời và mở ra những viễn cảnh mới, mang đến cho tổ chức phương tiện xử lý thông tin với tốc độ rất cao, lưu trữ thông tin với khối lượng rất lớn và truyền thông tin gần như tức thì và không giới hạn về khoảng cách. Những ưu việt đó vượt xa khả năng làm việc thủ công. Chúng giúp con người thực hiện những điều mà trong thế giới thủ công chỉ là mơ ước, với các ứng dụng ngày càng phong phú, đa dạng và phức tạp dựa trên những nền tảng công nghệ ngày một phát triển. Vì thế, nghiên cứu ứng dụng CNTT trong một tổ chức luôn dẫn đến mô hình ứng dụng (application model – tổ chức sẽ hoạt động như thế nào trong môi trường CNTT) và mô hình công nghệ (technology model – các ứng dụng được phát triển trên nền công nghệ nào).

Tổ chức là một thực thể thống nhất, nên mọi sự thay đổi ở một thành phần bên trong luôn luôn kéo theo sự thay đổi ở tất cả các thành phần còn lại. Khi CNTT xâm nhập vào tổ chức, làm thay đổi cách thức con người hoạt động thông tin bên trong tổ chức, kéo theo thay đổi cả về mô hình tổ chức lẫn mô hình thông tin. Nói theo ngôn ngữ quản lý, việc ứng dụng CNTT (hay điện tử hóa) chắc chắn làm thay đổi các quy trình làm việc thủ công (cải cách hành chính) theo hướng tạo điều kiện tốt nhất cho CNTT phát huy những năng lực phục vụ phù hợp với khả năng tiếp thu và phát triển của tổ chức.

Tổng hợp những ý trên dẫn chúng ta đến 4 hợp phần mà tất cả các phương pháp luận về CPĐT đều thống nhất lựa chọn là: Mô hình tổ chức + Mô hình thông tin (được xây dựng trên nền móng của chiến lược CPĐT về tổ chức); Mô hình ứng dụng + Mô hình công nghệ (được xây dựng trên nền móng của chiến lược CPĐT về CNTT).

Kiến trúc tổng thể là một kế hoạch chi tiết định hướng. Nó là một bức tranh kiến trúc đa chiều, giúp người ta phân tích các mối quan hệ đan chéo giữa tất cả các chiều nhằm tìm ra các nhân tố tạo nên sự phát triển ổn định và bền vững của tổ chức.

Khung kiến trúc tổng thể

Kiến trúc của một tổ chức là một tập hợp các mô hình được dùng làm cơ sở để phân tích, giúp các nhà quản lý quyết định thực hiện những thay đổi cần thiết để đạt được mục đích và mục tiêu của tổ chức đó. Các mô hình này thực hiện vai trò giống như các bản kế hoạch chi tiết hướng dẫn và phối hợp nỗ lực của các bộ phận liên quan trong việc xây dựng mới hoặc thay đổi một tổ chức hiện tại.

Thực tiễn cho thấy trong những tổ chức lớn, các mô hình tổ chức tại những bộ phận khác nhau thường được xây dựng bởi các nhóm khác nhau. Các nhóm này thường có xu hướng tạo ra những sản phẩm kiến trúc chỉ đáp ứng yêu cầu của riêng chứ không thể áp dụng ở nơi khác, còn nếu muốn áp dụng thì phải hiệu chỉnh rất nhiều. Vì thế, khi một tổ chức muốn chuẩn hóa kết quả làm việc của tất cả các nhóm vào kiến trúc tổng thể thì biện pháp đầu tiên là thiết lập một khung kiến trúc tổng thể chung (EA).

Khó có thể xây dựng một khung EA duy nhất chung cho tất cả mọi trường hợp do sự khác nhau về lĩnh vực , trình độ quản lý, nguồn nhân lực, khả năng đầu tư, trang bị, cơ chế vận động… Từ đây, xuất hiện những cách tiếp cận khác nhau về xây dựng khung EA cho những lớp tổ chức khác nhau.

Hình 4 trụ cột của EA

Người ta ghi nhận có 5 phương pháp được áp dụng nhiều nhất và được xem là có ảnh hưởng nhất:

• TOGAF (The Open Group Architecture Framework – Khung kiến trúc nhóm mở)
• The Zachman Framework (Khung Zachman)
• FEAF (Federal Enterprise Architecture Framework – Khung kiến trúc tổng thể kiểu liên bang)
• MDA (Model Driven Architecture – Kiến trúc được điều khiển bởi mô hình)
• EUP (Enterprise Unified Process – Quy trình hợp nhất tổ chức).
Mỗi phương pháp đưa ra một khung (framework) gồm nhiều mô hình con phân tích các khía cạnh khác nhau của kiến trúc cho một lớp tổ chức phù hợp. Trong số đó, theo ý kiến cá nhân, FEAF là phương pháp có cách diễn đạt sáng sủa và dễ hiểu hơn cả.

FEAF đặt tất cả các quy trình phát triển, từ kiến trúc nghiệp vụ, kiến trúc dữ liệu, kiến trúc ứng dụng và kiến trúc công nghệ hiện thời thông qua các mô hình kiến trúc và các quá trình chuyển đổi, chuẩn hóa để đạt tới kiến trúc nghiệp vụ, kiến trúc dữ liệu, kiến trúc ứng dụng và kiến trúc công nghệ tương lai trong một khung tổng thể thống nhất.

FEAF được sử dụng nhiều trong các tổ chức có trình độ phát triển tương đối cao, nơi hiện hữu môi trường ứng dụng tương đối đồng nhất. Nếu khởi đầu từ một môi trường ứng dụng không đồng nhất (có những ứng dụng được phát triển ở các cấp độ khác nhau trong cùng một tổ chức như thường thấy ở nước ta) thì TOGAF là phương pháp được xem là phù hợp.

Trong hệ thống phương pháp luận thiết kế hệ thống thông tin đương đại, EA đóng vai trò “nhạc trưởng”. Mỗi hợp phần của EA bao gồm nhiều nội dung riêng biệt.

TOGAF dựng lên một khung kiến trúc tổng thể gồm phần lõi và các thành phần mở rộng. Khung kiến trúc tổng thể lõi bao gồm:

• Kiến trúc nghiệp vụ: Mô tả các mục tiêu hoạt động, các hoạt động, các quy trình nghiệp vụ…
• Kiến trúc dữ liệu: Xác định các quan hệ giữa các tập hợp dữ liệu, các quy trình nghiệp vụ và dữ liệu
• Kiến trúc ứng dụng: Xác định mô hình ứng dụng, giao diện người – máy, cơ chế xử lý, các quy tắc nghiệp vụ
• Kiến trúc kỹ thuật: Thể hiện các mô hình dữ liệu vật lý, thiết kế hệ thống kỹ thuật, công nghệ và các cơ chế trình diễn, thiết kế các thủ tục và cơ chế kiểm soát.

Các thành phần mở rộng gồm:
• Các tiêu chuẩn, chính sách: Xác định các tiêu chuẩn, đề xuất các chính sách cho từng bộ phận cấu thành
• Kiến trúc an ninh: Xác định các yêu cầu và giải pháp về an ninh cho toàn bộ tổ chức, đặc biệt là an ninh dữ liệu
• Kiến trúc dịch vụ: Xác định cách thức cung cấp dịch vụ của tổ chức.
Đến tháng 11/2010, trong cả nước chỉ có TP.Đà Nẵng là đã xây dựng hoàn chỉnh kiến trúc tổng thể CPĐT (Kết quả của dự án CNTT-TT TP.Đà Nẵng). Khung kiến trúc tổng thể được đề xuất cho TP.Đà Nẵng có các thành phần được mô tả trong hình.