Work Breakdown Structure (WBS)

Click Here to View Video on YouTube:  5-Steps to Project Success

Download this Free Video (Same as above) (9MB file)

RIGHT Click & Save Target As: "5-Steps to Project Success - Seriously_v1.1"

You have permission to freely copy and distribute this video.

Introduction to the WBS

A Work Breakdown Structure is a results-oriented family tree that captures all the work of a project in an organized way.  It is often portrayed graphically as a hierarchical tree, however, it can also be a tabular list of "element" categories and tasks or the indented task list that appears in your Gantt chart schedule.  As a very simple example, Figure 1 shows a WBS for a hypothetical banquet.

Figure 1

Large, complex projects are organized and comprehended by breaking them into progressively smaller pieces until they are a collection of defined "work packages" that may include a number of tasks.  A $1,000,000,000 project is simply a lot of $50,000 projects joined together. The Work Breakdown Structure (WBS) is used to provide the framework for organizing and managing the work.

In planning a project, it is normal to find oneself momentarily overwhelmed and confused, when one begins to grasp the details and scope of even a modest size project.  This results from one person trying to understand the details of work that will be performed by a number of people over a period of time.  The way to get beyond being overwhelmed and confused is to to break the project into pieces, organize the pieces in a logical way using a WBS, and then get help from the rest of your project team.  

The psychologists say our brains can normally comprehend around 7-9 items simultaneously.  A project with thousands or even dozens of tasks goes way over our ability to grasp all at once.  The solution is to divide and conquer.  The WBS helps break thousands of tasks into chunks that we can understand and assimilate.   Preparing and understanding a WBS for your project is a big step towards managing and mastering its inherent complexity. 

The WBS is commonly used at the beginning of a project for defining project scope, organizing Gantt schedules and estimating costs.  It lives on, throughout the project, in the project schedule and often is the main path for reporting project costs.  On larger projects, the WBS may be used throughout the project to identify and track work packages, to organize data for Earned Value Management (EVM) reporting, for tracking deliverables, etc.

History of the WBS

The WBS was initially developed by the U.S. defense establishment, and it is described in Military Standard (MIL-STD) 881B (25 Mar 93) as follows: "A work breakdown structure is a product-oriented family tree composed of hardware, software, services, data and facilities .... [it] displays and defines the product(s) to be developed and/or produced and relates the elements of work to be accomplished to each other and to the end product(s)."

It requires some mental discipline to develop a product-oriented or deliverable-oriented grouping of project elements adding up to comprise the entire project scope. Intuitively, we tend to start out with a task-oriented approach. This is OK for very small projects where extensive project management controls will not be used. The task-oriented approach is easy to understand, because we can easily think of projects as collection of tasks. A task-oriented WBS can be developed by beginning with a simple "to-do" list and then clustering the items in a logical way. The logical theme could be project phases, functional areas, or major end-products.

If your organization will be collecting historical data to form a cost database, you should try to select a standard approach consistent with the organization’s long term data collection needs.

A sample WBS is shown in the figure below:

WBS Format for System Development Projects

Additional level 2 elements not shown here might include development environment support, logistics and training, and installation and startup.   This next link will take you to a skeleton sample WBS for a software and hardware system development project, and you can also download a zipped version of the corresponding MS-Project 2002 (.mpp) file.

A WBS for a large project will have multiple levels of detail, and the lowest WBS element will be linked to functional area cost accounts that are made up of individual work packages. Whether you need three levels or seven, work packages should add up through each WBS level to form the project total.

Product or Process Oriented?

The WBS was initially defined as a product oriented family tree, however subsequent definitions have introduced more flexibility -- so a WBS can also be deliverable or process oriented.  Your WBS can be built on nouns or verbs.  If the results of your project are primarily verbs, then a verb based or process based WBS may make more sense.  If your WBS is to be product or deliverable oriented, then you can start by thinking of the WBS as a parts list for the ultimate end-items of your project.  This link will give a simple illustration of a product or process based WBS orientation.  These differences are not shown to tell you what is the right way for your project, but just to familiarize you with the distinctions, so you can think about them and choose what's best for your project.

WBS Numbering

WBS elements are usually numbered, and the numbering system may be arranged any way you choose. The conventional numbering system is shown in the figure. The shaded box shown in the above slide could be numbered 1.2.2.3, which would tell you it was in the second box in level 2, the second box in level 3, and the third box in level 4.

WBS Dictionary

If a WBS is extensive and if the category content is not obvious to the project team members, it may be useful to write a WBS dictionary. The WBS dictionary describes what is in each WBS element, and it may also say what is not in an element, if that is unclear. Here is a sample of a WBS dictionary description:

WBS Element 1.5.4.5. - Systems Integration Test Equipment Planning - This element includes the effort to identify requirements and specify types and quantities of test equipment needed to support the System Integration and Test process. It does not include the design or procurement of such equipment, which is covered in Element 1.5.4.6.

Mapping WBS for Cost Management

In a product-oriented WBS, functional categories of work may form "cost accounts" within a WBS element. Cost account managers are responsible for a functional area’s contribution to a WBS element. Cost accounts from several departments or functions may combine into one WBS element.

Internal department planning for a cost account will be made up of individual work packages. A work package will typically have its own budget and schedule. Work packages should be small enough to be executed by individuals or small groups in a single department, and they should be of relatively short schedule duration. A small project might define a maximum work package size as two weeks of effort. Larger projects will assemble larger work packages that can be appropriately managed and controlled.

The project manager will have to decide to what degree employment of various details of WBS implementation will benefit the efficient management of the project. On a very small project, a formal WBS may serve no useful purpose, but it can become valuable if project size or complexity start to increase.

As an organization’s project management environment matures, or as larger size and complexity are encountered, application of the WBS concept can evolve from an ad hoc list of tasks, to time-phased activity lists, task lists clustered by project deliverables and services, or an end-product focused WBS fed by cost accounts and work packages.

If you are using MS-Project or a similar project management software application, you may encounter the WBS as a vertical list with indents to show structure. This will be compatible with the Gantt View data entry screens. While some software packages provide a separate WBS view, you could prepare your WBS in the vertical format using a word processor, and then cut and paste your WBS into your project management software package.

Program and Contract WBSs

A top-level WBS for a large program is sometimes called a Program WBS (PWBS) or Program Summary WBS (PSWBS). If a project involves several organizational participants or contractors, guidance for one contractor can be provided in a Contract WBS (CWBS). The project manager may provide a high-level CWBS for each developer, perhaps to level 2 or level 3.  The developer will then fill in the details of lower WBS levels to reflect the work to be accomplished and the data flow in that organization.

Organizational Standards

Your organization may want to decide on a standard WBS format or group of formats, use these across all projects, and communicate definitions widely so everyone will be speaking the same language. This can save re-learning project lessons and can lay the groundwork for successful data gathering to aid future cost estimates.

WBS Implementation

When you set up a project WBS, think about how you will be using it later in the project. Try to consider how you will organize the WBS, schedule format, manager assignments, and charge numbers, in your early project planning.  These days, the WBS in smaller projects ends up automatically being the indent structure in your Gantt schedule, so pay attention to those indents, and make sure that is the WBS you want for rolling up costs in your project, especially if you will be using EVM. It will be helpful if you can map the charge numbers, managers, and task groups to each other. This will help you track costs and progress for each manager. If your project schedule will on MS-Project, you may want to insert "text" columns into your schedule (Gantt View) for project charge numbers and manager names.

If your project charge numbers cannot be linked to groups of tasks assigned to specific managers, you will have no way to provide performance measurement feedback to managers.

Some project management environments have definite conventions for grouping items in a WBS. The best method is to have a WBS that works for your particular project environment. The WBS should be designed with consideration for its eventual uses. Your WBS design should try to achieve certain goals:

• Be compatible with how the work will be done and how costs and schedules will be managed,

• Give visibility to important or risky work efforts,

• Allow mapping of requirements, plans, testing, and deliverables,

• Foster clear ownership by managers and task leaders,

• Provide data for performance measurement and historical databases, and

• Make sense to the workers and accountants.

There are usually many ways to design a WBS for a particular project, and there are sometimes as many views as people in the process.   Experience teaches that everyone takes a slightly different slice of the apple, so make sure WBS arguments seeking metaphysical certainty are quickly brought to closure.  Simple practicality combined with enlightened trial and error usually is the best approach. 

Generating a WBS from Microsoft Project

There is a third-party add-on software application for MS-Project called WBS Chart Pro that will convert your Gantt chart task list with indents into a standard WBS graphic in a few clicks.   You can also use this application to create a WBS and transfer it back MSP.  I have found this software very valuable in organizing project work into a WBS, reviewing the scope of proposed projects, and helping managers visualize the WBS implicit in their MS-Project schedules.

PMI Practice Guide for WBS

The Project Management Institute (PMI) has a document, Project Management Institute Practice Standard for Work Breakdown Structures, that provides examples of WBS formats commonly used in several different project areas, construction, defense, etc.  From the PMI Web site, upper right corner, click on Publications & Information Resources, then on Bookstore.  Key word search for Work Breakdown Structure will bring up this standard and other references.

?Copyright 1997, 2004 James R. Chapman, All rights reserved.

Document Version 2.3 last updated February 26, 2007

Return to: Project Home

CMMI(Capability Maturity Model Integration)
- 조직 프로세스를 보다 적절히 관리하기 위해 준수해야 할 지침을 체계화 한 것.
- 5단계의 프로세스 Maturity 레벨이 있다.

평가 대상 영역
- 소프트웨어 개발
- 시스템 개발
- 프로젝트 관리
- 리스크 관리
- 시스템 조달, IT 서비스
- 인적관리

레벨1은 매우 미숙하고 혼돈된 개발 프로세스이며, 레벨5는 매우 성숙한 고품질을 실현하는 개발 프로세스이다.
1998년 기준으로 소프트웨어 개발을 실시하는 조직의 75%가 레벨1 이라고 추정된다.

CMM 모델?
- 미국의 카네기 멜론 대학의 Sofrware Engineering Inistitute가 IT 개발 프로세스 관리 능력 향상을 위해
  미국방성의 자금 지원을 받은 프로젝트 이다.
- 1986년부터 연구하여 1991년 발표된 표준 모델이다.
- 소프트웨어 이외에도 적용되는 분야가 많다.
- CMMI는 CMM의 후속 모델이며, 소프트웨어와 시스템 기술의 프로세스 개선을 위한 통합모델이며, 2001년에 발표되었다.

CMMI 프로세스
- 조직의 프로세스 개선을 통한 소프트웨어 개발 과정에서의 비용, 품질, 일정 등 모든 것을 충족시키며, 특정 성숙도 레벨로 진입하기 위한 최소한의 기준 제시와 반드시 수행해야 할 활동들의 집합으로 프로세스 프레임워크의 성숙도 향상을 위한 모델이다.

- CMMI 모델의 각 프로세스 영역(Process Areas)의 특별 목적(specific goals, SP)와 공통 목적(generic goals, GG)의 달성정도를 측정
  (프로세스 개선 수준을 나타냄)

- CMMI는 조직의 SW 개발뿐만 아니라 시스템설계, 하드웨어, 운영 등 시스템통합(System Integration, SI) 사업 전반에 대한 프로세스를 평가하고 정의하는 방법인 SCAMPI(Standard CMMI Appraisal Method for Process Improvement)를 제공

- 특히 제품 또는 서비스의 개발, 획득, 유지보수하기 위한 조직의 공정 및 관리 능력을 향상시키기 위한 가이드를 제공과 이를 통해 프로세스 개선 시 필요한 목표와 체계의 제공이 가능

[소프트웨어 프로세스 성숙도 레벨 5단계]
레벨 1(Initial)
- 개인의 역량에 따라 프로젝트의 성공과 실패가 좌우, 소프트웨어 개발 프로세스는 거의 없는 상태를 의미
- 표준화된 프로세스 없이 구행결과 예측이 곤란한 조직

레벨 2(Managed)
- 프로세스 하에서 프로젝트가 통제되는 수준으로 조직은 프로세스에 대한 어느 정도의 훈련이 되었다고 볼 수있다.
- 일정이나 비용과 같은 관리 프로세스 중심
- 기존 유사 성공사례를 응용하여 반복적으로 사용
- 기본 프로세스 구축에 의해 프로젝트가 관리되고 있는 조직

레벨 3(Defined)
- 레벨 2에서는 프로젝트를 위한 프로세스가 존재한다면 레벨 3에서는 조직을 위한 표준 프로세스가 존재함.
- 모든 프로젝트는 조직의 프로세스를 가져다 상황에 맞게 조정하여 승인받아 사용한다.
- 세부 표준 프로세스가 있어 프로젝트가 통제되는 조직

레벨 4(Quantitatively Managed)
- 소프트웨어 프로세스와 소프트웨어 품질에 대한 정량적인 측정이 가능
- 조직은 프로세스 데이터베이스를 구축하여 각 프로젝트에서 측정된 결과를 일괄적으로 수집하고 분석하여 품질평가를 위한 기준으로 삼는다.
- 프로젝트 활동이 정략적으로 관리․통제되고 성과 예측이 가능한 조직

레벨 5(Optimizing)
- 이 레벨에서는 지속적인 개선에 치중한다.
- 조직적으로 최적화된 프로세스를 적용하여 다시 피드백을 받아 개선하는 상위 단계이다.
- 지속적인 개선활동이 정착화 되고 최적의 관리로 프로젝트가 수행되는 조직

CMM은 미국 카네기 멜론 대학의 소프트웨어 공학 연구소(Software Engineering Inistitute)
정부기관 계약시 기본적으로 레벨 3를 요구하는 수준이다.

[참고]
1. 위키디피아

ScottGu's Blog에 올라온 ASP.NET MVC Framework에 대한 내용 입니다.

ScottGu's Blog: http://weblogs.asp.net/scottgu/archive/ ··· t-1.aspx

using System;
using System.Text;
using System.Data;
using System.Net;
using System.IO;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

public partial class XXXX_PrintData : BasePage
{
    protected void Page_Load(object sender, EventArgs e)
    {
        ViewWebPage();
    }

    public void ViewWebPage()
    {
        HttpWebRequest objWebRequest = null;
        HttpWebResponse objWebResponse = null;
        StreamReader objStreamReader = null;

        NetworkCredential networkCred = new NetworkCredential("", "");
        CredentialCache networkCache = new CredentialCache();

        string strUrl = "";

        objWebRequest = (HttpWebRequest)WebRequest.Create(strUrl);
        networkCache.Add(new Uri(strUrl), "Basic", networkCred);
        objWebRequest.Credentials = networkCred;
        objWebResponse = (HttpWebResponse)objWebRequest.GetResponse();
        objStreamReader = new StreamReader(objWebResponse.GetResponseStream(), Encoding.GetEncoding(949));

        string strLine = string.Empty;
        string strBody = string.Empty;
        while (objStreamReader.Peek() != -1)
        {
            strLine = objStreamReader.ReadLine();
            this.viewPrintTable.InnerHtml += strLine + "\r\n";
        }
    }

    private string Chr(int p)
    {
        throw new Exception("The method or operation is not implemented.");
    }

    private void StreamReader(Stream stream, object p)
    {
        throw new Exception("The method or operation is not implemented.");
    }
}

출처:http://blogs.msdn.com/buckh/archive/2004/07/28/199706.aspx

Authentication in web services with HttpWebRequest

Hatteras has three tiers: client, middle, and data.  The middle tier is an ASP.NET web service on a Windows 2003 Server running IIS 6.  When the client (we use C# for both it and the middle tier) connects to the middle tier, it must authenticate with IIS 6.  Depending upon the IIS configuration, that may be negotiate, NTLM, Kerberos, basic, or digest authentication.  Here's a page on Internet Authentication in .NET.

NOTE:  The code below uses the .NET 2.0 framework (Visual Studio 2005).

In order to authenticate, the client must have credentials that the server recognizes as valid.  For Windows Integrated Authentication (comprising NTLM and Kerberos) using the current logged-on user, the client can use CredentialCache.DefaultCredentials.  Here's how it looks in code.

using System;
using System.IO;
using System.Net;

class Creds
{
    public static void Main(string[] args)
    {
        Uri uri = new Uri(args[0]);

        HttpWebRequest req = (HttpWebRequest)WebRequest.Create(uri);
        req.Credentials = CredentialCache.DefaultCredentials;

        // Get the response.
        using (HttpWebResponse res = (HttpWebResponse)req.GetResponse())
        {
            StreamReader sr = new StreamReader(res.GetResponseStream());
            Console.WriteLine(sr.ReadToEnd());
        }
    }
}

You can find that same type of sample code in MSDN.  However, it gets more interesting if you want to use basic or digest authentication or use credentials other than the current logged-on user.

One interesting fact is that the HttpWebRequest.Credentials property is of type ICredentials, but it only uses instances of NetworkCredential and CredentialCache.  If you implement ICredentials on your own class that is not one of those two classes, you can assign it to the Credentials property, but HttpWebRequest will silently ignore it.

To go further, we need to look at the CredentialCache class itself.  This class is used to hold a set of credentials that are associated with hosts and authentication types.  It has two static properties, one of which we used above, that are the "authentication credentials for the current security context in which the application is running," which means the logged-on user in our case.

• ICrendentials DefaultCredentials
• NetworkCredential DefaultNetworkCredentials

The difference is very subtle.  The documentation for DefaultCredentials says, "The ICredentials instance returned by DefaultCredentials cannot be used to view the user name, password, or domain of the current security context."  The instance returned by DefaultNetworkCredentials, being new in .NET 2.0 and of type NetworkCredential, would presumably let you get the user name and domain, but it didn't work for me when I tried it with the following code (UserName returned an empty string).

Console.WriteLine("User name: " + CredentialCache.DefaultNetworkCredentials.UserName);

The NetworkCredential class implements both the ICredentials (NetworkCredential GetCredential(Uri uri, String authType)) and ICredentialsByHost (NetworkCredential GetCredential(String host, int port, String authType)) interfaces.  The ICredentialsByHost interface is new in .NET 2.0.

The CredentialCache class has methods that let you add, get, and remove credentials for particular hosts and authentication types.  Using this class, we can manually construct what setting req.Credentials = CredentialCache.DefaultCredentials accomplished in the original example.

        CredentialCache credCache = new CredentialCache();
        credCache.Add(new Uri("http://localhost"), "Negotiate",
                      CredentialCache.DefaultNetworkCredentials);
        HttpWebRequest req = (HttpWebRequest)WebRequest.Create(uri);
        req.Credentials = credCache;

The authentication type can also be explicitly specified as "NTLM" and "Kerberos" in separate calls to Add().  This page on authentication schemes explains using Negotiate as follows.

Negotiates with the client to determine the authentication scheme. If both client and server support Kerberos, it is used; otherwise NTLM is used.

Let's say you want to work with basic or digest authentication.  The documentation for CredentialsCache.DefaultCredentials and CredentialsCache.DefaultNetworkCredential says that neither will work with basic or digest.  If we add basic to credentials cache, we get a runtime exception.

        credCache.Add(new Uri("http://localhost"), "Basic",
                      CredentialCache.DefaultNetworkCredentials);

The exception is thrown by the Add() method.

Unhandled Exception: System.ArgumentException: Default credentials cannot be supplied 
for the Basic authentication scheme.
Parameter name: authType
at System.Net.CredentialCache.Add(Uri uriPrefix, String authType, NetworkCredential cred)

So, in order to use basic or digest, we must create a NetworkCredential object, which is also what we need to do in order to authenticate as some identity other than the logged-on user.  To do that, we create NetworkCredential object and add it to the CredentialCache as follows.

        credCache.Add(new Uri("http://localhost"), "Basic" /* or "Digest" */,
                      new NetworkCredential("me", "foo", "DOMAIN"));

Basic authentication sends the password across the wire in plain text.  That's okay for a secure connection, such as one using SSL, and for situations where you don't need much security.  Digest authentication hashes the password along with other data from the server before sending a response over the wire.  It's a significant step up from basic.

Now we need to have the user name and password to create the NetworkCredential object.  There are two parts to this.  First is prompting the user for the name and password.  The second is storing the information.  For prompting there is the Windows dialog that pops up any time you go to a web site that requires authentication.  That dialog includes a "Remember my password" checkbox.  I don't yet know what the managed API is for that.

To store and retrieve the information, there is the new managed DPAPI explained by Shawn Farkas in several blog postings.

• Managed DPAPI Part I: ProtectedData talks about persisting information securely using the new ProtectedData class
• Managed DPAPI Part II: ProtectedMemory talks about storing information in RAM securely using the new ProtectedMemory class
• Making Strings More Secure talks about the new SecureString class that makes use of ProtectedMemory

[Update 3:44pm]  The Windows dialog used when IE prompts for name and password is created by the CredUIPromptForCredentials() function.  CredUIConfirmCredentials() is used to save credentials that authenticated successfully, if desired.  Duncan Mackenzie's MSDN article Using Credential Management in Windows XP and Windows Server 2003 explains how to use it from .NET.

[UPDATE 4/10/2006]  I updated the MSDN links that were broken.

#define DEBUG
using System;
using System.IO;
using System.Text;
using System.Threading;
using System.Configuration;
using System.Collections;
using System.Data;
using System.Data.SqlClient;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Web.Configuration;

using Microsoft.VisualStudio.Tools.Applications.Runtime;
using Word = Microsoft.Office.Interop.Word;
using Graph = Microsoft.Office.Interop.Graph;
using Office = Microsoft.Office.Core;
using Excel = Microsoft.Office.Tools.Excel;

public partial class CERS_Tot_MonthM : BasePage
{

    #region 변수선언부

    //날짜 변수
    string strYear      = string.Empty;
    string strMonth     = string.Empty;
    string strDay       = string.Empty;
    string nowDate      = string.Empty;

    //변수설정
    Word.Range          wrdRng1;
    Word.Range          wrdRng2;
    Word.Range          wrdRng3;
    Word.Range          wrdRng4;
    Word.Range          wrdRng5;
    Word.Range          wrdRng6;
    Word.Range          wrdRng7;

    Word._Application   oWord;
    Word._Document      oDoc;

    //Bookmarks 객체변수 선언
    object bookmark1    = null;
    object bookmark2    = null;
    object bookmark3    = null;
    object bookmark4    = null;
    object bookmark5    = null;
    object bookmark6    = null;
    object bookmark7    = null;

    object oMissing     = System.Reflection.Missing.Value;
    string mhtFileName  = string.Empty;
    string getFileName  = string.Empty;  //파일명(Doc, Mht)
    string getFilePath  = string.Empty;  //파일경로

    #endregion

    #region 페이지로드 이벤트메서드
    /// <summary>
    /// 페이지로드 이벤트메서드
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void Page_Load(object sender, EventArgs e)
    {
        //페이지 타이틀 및 사이트네비게이션 설정
        this.lblTitle.Text          = "";
        this.spnSiteNavi.InnerHtml  = "";

        if (!IsPostBack)
        {
            //월
            string strMonth         = "00" + DateTime.Now.Month.ToString();

            //웹페이지에 날짜를 저장
            this.cal_Month.Value    = DateTime.Now.Year + "-" + strMonth.Substring((strMonth.Length - 2), 2);

            //iframe 활성화 여부
            ShowWordMht1.Visible    = false;

            //다운로드버튼 활성화 여부
            spnDownLoad.Visible     = true;

            //로그인 여부 확인 후 서브메뉴생성
            if (Session["sid"] != null)
            {
                if (Session["sid"].ToString() == CustId)
                {
                    //연구소 권한
                    if (CustGrade == "0") { }

                    //고객사 권한
                    if (CustGrade == "1")
                    {
                        MakeSubMenu();
                    }

                    //지점 권한
                    if (CustGrade == "2")
                    {
                        ShowMessageBox("XX권한으로 접근할 수 없습니다.", "");
                    }
                }
                else
                {
                    Response.Redirect("");
                }
            }
            else
            {
                Response.Redirect("");
            }

            spnDownLoad.InnerHtml = "[다운로드]";
        }

        this.hdnCustCode.Value = CustId;
        this.hdnFilePath.Value = Server.UrlEncode(WebConfigurationManager.AppSettings["XXXXXX"].ToString() + "\\Doc\\");
    }
    #endregion

    #region 디렉토리 관리 부분(CreateDirectory, CreateDoc, ShowMht)

    #region 디렉토리 생성 메서드
    /// <summary>
    /// 디렉토리 생성 메서드
    /// </summary>
    private static void CreateDirectory(string ParentDir, string ChildDir1, string ChildDir2)
    {
        if (!Directory.Exists(ParentDir))
        {
            DirectoryInfo di = Directory.CreateDirectory(ParentDir);

            if (!Directory.Exists(ChildDir1))
            {
                DirectoryInfo cdi = Directory.CreateDirectory(ChildDir1);
            }
            if (!Directory.Exists(ChildDir2))
            {
                DirectoryInfo cdi = Directory.CreateDirectory(ChildDir2);
            }
        }
        else
        {
            if (!Directory.Exists(ChildDir1))
            {
                DirectoryInfo cdi = Directory.CreateDirectory(ChildDir1);
            }
            if (!Directory.Exists(ChildDir2))
            {
                DirectoryInfo cdi = Directory.CreateDirectory(ChildDir2);
            }
        }
    }
    #endregion

    #region Doc 파일 생성메서드
    /// <summary>
    /// Doc파일 생성 메서드
    /// </summary>
    /// <param name="oMissing"></param>
    /// <param name="oWord"></param>
    /// <param name="oDoc"></param>
    /// <param name="bookmark2"></param>
    /// <param name="FileName"></param>
    /// <returns></returns>
    private void CreateDoc(ref object oMissing, Word._Application oWord, Word._Document oDoc, ref object FileName)
    {
        try
        {
            //bookmark의 Range를 할당
            wrdRng1                         = oDoc.Bookmarks.get_Item(ref bookmark1).Range;
            wrdRng2                         = oDoc.Bookmarks.get_Item(ref bookmark2).Range;
            wrdRng3                         = oDoc.Bookmarks.get_Item(ref bookmark3).Range;
            wrdRng4                         = oDoc.Bookmarks.get_Item(ref bookmark4).Range;
            wrdRng5                         = oDoc.Bookmarks.get_Item(ref bookmark5).Range;
            wrdRng6                         = oDoc.Bookmarks.get_Item(ref bookmark6).Range;
            wrdRng7                         = oDoc.Bookmarks.get_Item(ref bookmark7).Range;
           
            //표와 그래프 그리기
            DrawContent();

            //저장되는 문서 옵션
            object FileFormat               = Word.WdSaveFormat.wdFormatRTF;
            object LockComments             = false;
            object AddToRecentFiles         = true;
            object ReadOnlyRecommended      = false;
            object EmbedTrueTypeFonts       = false;
            object SaveNativePictureFormat  = true;
            object SaveFormsData            = true;
            object SaveAsAOCELetter         = false;
            object Encoding                 = false;
            object InsertLineBreaks         = false;
            object AllowSubstitutions       = false;
            object LineEnding               = Word.WdLineEndingType.wdCRLF;
            object AddBiDiMarks             = false;

            //저장하기
            oDoc.SaveAs(ref FileName, ref FileFormat, ref oMissing,
                    ref oMissing, ref AddToRecentFiles, ref oMissing,
                    ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing, ref oMissing);
        }
        catch (Exception ex)
        {
            ShowMessageBox(ex.ToString(), "WIN");
        }
        finally
        {
            oWord.Quit(ref oMissing, ref oMissing, ref oMissing);
        }
    }
    #endregion

    #region Mht 파일 생성메서드
    /// <summary>
    /// Mth파일 생성
    /// </summary>
    /// <param name="oMissing"></param>
    /// <param name="oWord"></param>
    /// <param name="oDoc"></param>
    /// <param name="bookmark2"></param>
    /// <param name="FileName"></param>
    /// <returns></returns>
    private void ShowMht(ref object oMissing, Word._Application oWord, Word._Document oDoc, ref object FileName)
    {
        try
        {
            //bookmark의 Range를 할당
            wrdRng1                         = oDoc.Bookmarks.get_Item(ref bookmark1).Range;
            wrdRng2                         = oDoc.Bookmarks.get_Item(ref bookmark2).Range;
            wrdRng3                         = oDoc.Bookmarks.get_Item(ref bookmark3).Range;
            wrdRng4                         = oDoc.Bookmarks.get_Item(ref bookmark4).Range;
            wrdRng5                         = oDoc.Bookmarks.get_Item(ref bookmark5).Range;
            wrdRng6                         = oDoc.Bookmarks.get_Item(ref bookmark6).Range;
            wrdRng7                         = oDoc.Bookmarks.get_Item(ref bookmark7).Range;
           
            //표와 그래프 그리기
            DrawContent();
            //DrawGraph();

            //저장되는 문서 옵션
            object FileFormat               = Word.WdSaveFormat.wdFormatHTML;
            object LockComments             = false;
            object AddToRecentFiles         = true;
            object ReadOnlyRecommended      = false;
            object EmbedTrueTypeFonts       = false;
            object SaveNativePictureFormat  = true;
            object SaveFormsData            = true;
            object SaveAsAOCELetter         = false;
            object Encoding                 = false;
            object InsertLineBreaks         = false;
            object AllowSubstitutions       = false;
            object LineEnding               = Word.WdLineEndingType.wdCRLF;
            object AddBiDiMarks             = false;

            //저장하기
            oDoc.SaveAs(ref FileName, ref FileFormat, ref oMissing,
                    ref oMissing, ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing, ref oMissing,
                    ref oMissing, ref oMissing, ref oMissing);
        }
        catch (Exception ex)
        {
            ShowMessageBox(ex.ToString(), "WIN");
        }
        finally
        {
            oWord.Quit(ref oMissing, ref oMissing, ref oMissing);
        }
    }
    #endregion

    #endregion

    #region 문서 생성 메서드
    /// <summary>
    /// 문서생성 메서드
    /// </summary>
    private void CreateDoc()
    {
        //iframe 활성화 여부
        this.ShowWordMht1.Visible   = true;

        //string strSdate             = "";
        object conffileName         = null;
        object fileName             = null;
        string confParentdir        = string.Empty;
        string strParentdir         = string.Empty;
        string strChildDir1         = string.Empty;     //Doc 파일 경로
        string strChildDir2         = string.Empty;     //Mht 파일 경로
        string sourceFileName1      = string.Empty;
        string sourceFileName2      = string.Empty;

        sourceFileName1             = WebConfigurationManager.AppSettings["XXXXX"].ToString();
        confParentdir               = WebConfigurationManager.AppSettings["XXXXX"].ToString();
        fileName                    = sourceFileName1;
        strParentdir                = confParentdir;
        strChildDir1                = strParentdir + "\\" + "Doc\\";
        strChildDir2                = strParentdir + "\\" + "Mht\\";

        //폴더 검사! 없으면 생성
        CreateDirectory(strParentdir, strChildDir1, strChildDir2);

        //파일명을 생성한다.
        object FileName1    = strChildDir1 + this.hdnCustCode.Value + "_" + this.cal_Month.Value.Replace("-", "") + ".doc";
        object FileName2    = strChildDir2 + this.hdnCustCode.Value + "_" + this.cal_Month.Value.Replace("-", "") + ".htm";
        mhtFileName         = this.hdnCustCode.Value + "_" + this.cal_Month.Value.Replace("-", "") + ".htm";

        //전역 파일경로 변수에 경로 할당
        getFilePath         = strChildDir1;

        //전역 파일이름 변수에 파일이름 할당
        getFileName         = (string)FileName1;

        //기존 Doc 파일 존재 여부를 검사
        try
        {
            oWord = (Word.Application)Server.CreateObject("Word.Application");
            oWord.Visible = true;
            oDoc = oWord.Documents.Add(ref fileName, ref oMissing, ref oMissing, ref oMissing);

            if (File.Exists(FileName1.ToString()))
            {
                File.Delete(FileName1.ToString());

                //Doc파일생성
                CreateDoc(ref oMissing, oWord, oDoc, ref FileName1);
                File.Delete(strChildDir1 + "Normal" + ".dot");
                File.Delete(strChildDir1 + "~Normal" + ".dot");
            }
            else
            {
                //Doc파일생성
                CreateDoc(ref oMissing, oWord, oDoc, ref FileName1);
                File.Delete(strChildDir1 + "Normal" + ".dot");
                File.Delete(strChildDir1 + "~Normal" + ".dot");
            }
        }
        catch (Exception ex)
        {
           
        }

        try
        {
            //mht 파일 존재 여부를 검사
            oWord = (Word.Application)Server.CreateObject("Word.Application");
            oWord.Visible = true;
            oDoc = oWord.Documents.Add(ref fileName, ref oMissing, ref oMissing, ref oMissing);

            if (File.Exists(FileName2.ToString()))
            {
                File.Delete(FileName2.ToString());
                Directory.Delete(strChildDir2 + mhtFileName.Replace("htm", "files"));

                //mht파일생성
                ShowMht(ref oMissing, oWord, oDoc, ref FileName2);
                File.Delete(strChildDir2 + "Normal" + ".dot");
                File.Delete(strChildDir2 + "~Normal" + ".dot");
            }
            else
            {
                //mht파일생성
                ShowMht(ref oMissing, oWord, oDoc, ref FileName2);
                File.Delete(strChildDir2 + "Normal" + ".dot");
                File.Delete(strChildDir2 + "~Normal" + ".dot");
            }
        }
        catch (Exception ex)
        {
           
        }
    }
    #endregion

    #region 문서 Content 생성(Draw Table, Draw Graph)

    #region Draw Content Method
    /// <summary>
    /// Draw Content Method
    /// </summary>
    private void DrawContent()
    {
        string nowFDate             = nowDate + "01";
        string nowTDate             = nowDate + "31";

        //오늘 날짜
        SqlParameter[] param        = new SqlParameter[3];
        param[0]                    = new SqlParameter("@CustId", CustId);
        param[1]                    = new SqlParameter("@FDate", nowFDate);
        param[2]                    = new SqlParameter("@TDate", nowTDate);

        SqlHelper dac               = new SqlHelper();
        DataSet ds                  = dac.ExecuteDataset(ConnectionString, CommandType.StoredProcedure, "[dbo].[XXXXX]", param);

        Word.Table tb1              = null;
        Word.Table tb2              = null;
        Word.Table tb3              = null;

        wrdRng1.Text                = this.cal_Month.Value.Substring(5,2);
        wrdRng2.Text                = ds.Tables[0].Rows[0][0].ToString();
        wrdRng3.Text                = ds.Tables[0].Rows[0][1].ToString();
        wrdRng4.Text                = this.cal_Month.Value.Substring(0, 4) +"년 " +this.cal_Month.Value.Substring(5, 2) + "월";

        tb1                         = ServiceTableList(ds, tb1);
        tb2                         = BugsTableList(ds, tb2);
        tb3                         = DivisionTableList(ds, tb3);

    }

    #region 테이블 1
    /// <summary>
    /// 테이블 1 생성 메서드
    /// </summary>
    /// <param name="ds"></param>
    /// <param name="tb1"></param>
    /// <returns></returns>
    private Microsoft.Office.Interop.Word.Table ServiceTableList(DataSet ds, Word.Table tb1)
    {
        int tb1RowCnt               = ds.Tables[1].Rows.Count;
        int tb1ColCnt               = ds.Tables[1].Columns.Count;
       
        //테이블 존재여부 검사
        if (oDoc.Tables.Count != 0)
        {
            //테이블 생성하기
            //테이블 Header 셋팅
            tb1 = oDoc.Tables.Add(wrdRng5, 1, tb1ColCnt, ref oMissing, ref oMissing);
            tb1.Range.Tables[1].Rows[1].Cells[1].Range.Text = "Title1";
            tb1.Range.Tables[1].Rows[1].Cells[2].Range.Text = "Title2";
            tb1.Range.Tables[1].Rows[1].Cells[3].Range.Text = "Title3";
            tb1.Range.Tables[1].Rows[1].Cells[4].Range.Text = "Title4";
            tb1.Range.Tables[1].Rows[1].Cells[5].Range.Text = "Title5";
            tb1.Range.Tables[1].Rows[1].Cells[6].Range.Text = "Title6";
            tb1.Range.Tables[1].Rows[1].Cells[7].Range.Text = "Title7";
            tb1.Range.Tables[1].Rows[1].Cells[8].Range.Text = "Title8";

            //테이블 Cell 넓이, 스타일
            tb1.Range.Tables[1].Rows[1].Cells[1].SetWidth(130, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[2].SetWidth(100, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[3].SetWidth(60, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[4].SetWidth(60, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[5].SetWidth(30, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[6].SetWidth(60, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[7].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
            tb1.Range.Tables[1].Rows[1].Cells[8].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
        }

        //데이터로우로 부터 테이블에 데이터를 추가한다.
        if (tb1.Range.Tables.Count > 0)
        {
            try
            {
                Microsoft.Office.Interop.Word.Row newRow = null;
                if (tb1RowCnt == 0)
                {
                    //newRow.Cells.Merge();
                }
                else
                {
                    for (int i = 0; i < tb1RowCnt; i++)
                    {
                        newRow = tb1.Range.Tables[1].Rows.Add(ref oMissing);
                        newRow.Cells[1].SetWidth(130, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[2].SetWidth(100, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[3].SetWidth(60, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[4].SetWidth(60, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[5].SetWidth(30, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[6].SetWidth(60, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[7].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[8].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);

                        //루프를 돌면서 Cell에 내용을 출력
                        for (int j = 0; j < tb1ColCnt; j++)
                        {
                            int k = j + 1;
                            newRow.Cells[k].Range.Text = ds.Tables[1].Rows[i][j].ToString();
                        }
                    }
                }

                newRow = null;
            }
            catch (Exception ex)
            {
               
            }
        }

        //테이블 보더 스타일
        tb1.Borders.InsideLineStyle     = Word.WdLineStyle.wdLineStyleSingle;
        tb1.Borders.OutsideLineStyle    = Word.WdLineStyle.wdLineStyleSingle;

        return tb1;
    }
    #endregion

    #region 테이블 2
    /// <summary>
    /// 테이블2 생성메서드
    /// </summary>
    /// <param name="ds"></param>
    /// <param name="tb2"></param>
    /// <returns></returns>
    private Microsoft.Office.Interop.Word.Table BugsTableList(DataSet ds, Microsoft.Office.Interop.Word.Table tb2)
    {
        int tb2RowCnt = ds.Tables[2].Rows.Count;
        int tb2ColCnt = ds.Tables[2].Columns.Count;

        //테이블 존재여부 검사
        if (oDoc.Tables.Count != 0)
        {
            //테이블 생성하기
            //테이블 Header 셋팅
            tb2 = oDoc.Tables.Add(wrdRng6, 1, tb2ColCnt, ref oMissing, ref oMissing);
            tb2.Range.Tables[1].Rows[1].Cells[1].Range.Text = "Title1";
            tb2.Range.Tables[1].Rows[1].Cells[2].Range.Text = "Title2";
            tb2.Range.Tables[1].Rows[1].Cells[3].Range.Text = "Title3";
            tb2.Range.Tables[1].Rows[1].Cells[4].Range.Text = "Title4";
            tb2.Range.Tables[1].Rows[1].Cells[5].Range.Text = "Title5";
            tb2.Range.Tables[1].Rows[1].Cells[6].Range.Text = "Title6";
            tb2.Range.Tables[1].Rows[1].Cells[7].Range.Text = "Title7";
            tb2.Range.Tables[1].Rows[1].Cells[8].Range.Text = "Title8";
            tb2.Range.Tables[1].Rows[1].Cells[9].Range.Text = "Title9";
            tb2.Range.Tables[1].Rows[1].Cells[10].Range.Text = "Title10";

            //테이블 Cell 넓이, 스타일
            tb2.Range.Tables[1].Rows[1].Cells[1].SetWidth(130, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[2].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[3].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[4].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[5].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[6].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[7].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[8].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[9].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
            tb2.Range.Tables[1].Rows[1].Cells[10].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
        }

        //데이터로우로 부터 테이블에 데이터를 추가한다.
        if (tb2.Range.Tables.Count > 0)
        {
            try
            {
                Microsoft.Office.Interop.Word.Row newRow = null;
                if (tb2RowCnt == 0)
                {
                    newRow.Cells.Merge();
                }
                else
                {
                    for (int i = 0; i < tb2RowCnt; i++)
                    {
                        newRow = tb2.Range.Tables[1].Rows.Add(ref oMissing);
                        newRow.Cells[1].SetWidth(130, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[2].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[3].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[4].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[5].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[6].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[7].SetWidth(45, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[8].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[9].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[10].SetWidth(50, Word.WdRulerStyle.wdAdjustNone);

                        //루프를 돌면서 Cell에 내용을 출력
                        for (int j = 0; j < tb2ColCnt; j++)
                        {
                            int k = j + 1;
                            newRow.Cells[k].Range.Text = ds.Tables[2].Rows[i][j].ToString();
                        }
                    }
                }
            }
            catch(Exception ex)
            {
           
            }
        }

        //테이블 보더 스타일
        tb2.Borders.InsideLineStyle     = Word.WdLineStyle.wdLineStyleSingle;
        tb2.Borders.OutsideLineStyle    = Word.WdLineStyle.wdLineStyleSingle;

        return tb2;
    }
    #endregion

    #region 테이블 3
    /// <summary>
    /// 테이블 3 생성 메서드
    /// </summary>
    /// <param name="ds"></param>
    /// <param name="tb3"></param>
    /// <returns></returns>
    private Microsoft.Office.Interop.Word.Table DivisionTableList(DataSet ds, Word.Table tb3)
    {
        int tb3RowCnt = ds.Tables[3].Rows.Count;
        int tb3ColCnt = ds.Tables[3].Columns.Count;

        //테이블 존재여부 검사
        if (oDoc.Tables.Count != 0)
        {
            //테이블 생성하기
            //테이블 Header 셋팅
            tb3 = oDoc.Tables.Add(wrdRng7, 1, tb3ColCnt, ref oMissing, ref oMissing);
            tb3.Range.Tables[1].Rows[1].Cells[1].Range.Text = "Title1";
            tb3.Range.Tables[1].Rows[1].Cells[2].Range.Text = "Title2";
            tb3.Range.Tables[1].Rows[1].Cells[3].Range.Text = "Title3";
            tb3.Range.Tables[1].Rows[1].Cells[4].Range.Text = "Title4";
            tb3.Range.Tables[1].Rows[1].Cells[5].Range.Text = "Title5";
            tb3.Range.Tables[1].Rows[1].Cells[6].Range.Text = "Title6";
            tb3.Range.Tables[1].Rows[1].Cells[7].Range.Text = "Title7";

            //테이블 Cell 넓이, 스타일
            tb3.Range.Tables[1].Rows[1].Cells[1].SetWidth(130, Word.WdRulerStyle.wdAdjustNone);
            tb3.Range.Tables[1].Rows[1].Cells[2].SetWidth(70, Word.WdRulerStyle.wdAdjustNone);
            tb3.Range.Tables[1].Rows[1].Cells[3].SetWidth(150, Word.WdRulerStyle.wdAdjustNone);
            tb3.Range.Tables[1].Rows[1].Cells[4].SetWidth(25, Word.WdRulerStyle.wdAdjustNone);
            tb3.Range.Tables[1].Rows[1].Cells[5].SetWidth(100, Word.WdRulerStyle.wdAdjustNone);
            tb3.Range.Tables[1].Rows[1].Cells[6].SetWidth(40, Word.WdRulerStyle.wdAdjustNone);
            tb3.Range.Tables[1].Rows[1].Cells[7].SetWidth(40, Word.WdRulerStyle.wdAdjustNone);
        }

        //데이터로우로 부터 테이블에 데이터를 추가한다.
        if (tb3.Range.Tables.Count > 0)
        {
            try
            {
                Microsoft.Office.Interop.Word.Row newRow = null;
                if (tb3RowCnt == 0)
                {
                    //newRow.Cells.Merge();
                }
                else
                {
                    for (int i = 0; i < tb3RowCnt; i++)
                    {
                        newRow = tb3.Range.Tables[1].Rows.Add(ref oMissing);
                        newRow.Cells[1].SetWidth(130, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[2].SetWidth(70, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[3].SetWidth(150, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[4].SetWidth(25, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[5].SetWidth(100, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[6].SetWidth(40, Word.WdRulerStyle.wdAdjustNone);
                        newRow.Cells[7].SetWidth(40, Word.WdRulerStyle.wdAdjustNone);

                        //루프를 돌면서 Cell에 내용을 출력
                        for (int j = 0; j < tb3ColCnt; j++)
                        {
                            int k = j + 1;
                            newRow.Cells[k].Range.Text = ds.Tables[3].Rows[i][j].ToString();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
           
            }
        }

        //테이블 보더 스타일
        tb3.Borders.InsideLineStyle     = Word.WdLineStyle.wdLineStyleSingle;
        tb3.Borders.OutsideLineStyle    = Word.WdLineStyle.wdLineStyleSingle;

        return tb3;
    }
    #endregion

    #endregion

    #region Draw Graph Method
    ///// <summary>
    /////  Draw Graph Method
    ///// </summary>
    //private void DrawGraph()
    //{
    //    //오늘 날짜
    //    string strMonth = DateTime.Now.Month.ToString();
    //    string strDay = DateTime.Now.Day.ToString();

    //    if (int.Parse(strMonth) < 10)
    //        strMonth = "0" + strMonth;

    //    if (int.Parse(strDay) < 10)
    //        strDay = "0" + strDay;

    //    string nowDate = DateTime.Now.Year.ToString() + strMonth + strDay;
    //    string spName = "dbo.XXXXX";

    //    SqlParameter[] param = new SqlParameter[3];
    //    param[0] = new SqlParameter("@CompCode", CustId);
    //    param[1] = new SqlParameter("@FDate", nowDate);
    //    param[2] = new SqlParameter("@TDate", this.cal_Month.Value.Substring(0, 4) + this.cal_Month.Value.Substring(5, 2) + "31");

    //    SqlHelper dac = new SqlHelper();
    //    DataSet ds = dac.ExecuteDataset(ConnectionString, CommandType.StoredProcedure, spName, param);

    //    //Chart 설정
    //    Graph.Chart wrdChart;
    //    Graph.Axis axis;
    //    DataTable dtSheet = ds.Tables[0];
    //    object oClassType = "MSGraph.Chart.8";

    //    //차트
    //    wrdChart = (Graph.Chart)wrdRng7.InlineShapes.AddOLEObject(ref oClassType, ref oMissing, ref oMissing, ref oMissing, ref oMissing, ref oMissing, ref oMissing, ref oMissing).OLEFormat.Object;

    //    wrdChart.Application.PlotBy = Graph.XlRowCol.xlColumns;
    //    wrdChart.ChartType = Microsoft.Office.Interop.Graph.XlChartType.xlAreaStacked;
    //    axis = (Graph.Axis)wrdChart.Axes(1, 1);

    //    //Make Header of Sheet
    //    wrdChart.Application.DataSheet.Cells.Clear();
    //    for (int i = 0; i < dtSheet.Columns.Count; i++)
    //    {
    //        wrdChart.Application.DataSheet.Cells[1, i + 1] = dtSheet.Columns[i].ColumnName;
    //    }

    //    //Make DataSheet
    //    for (int i = 0; i < dtSheet.Rows.Count; i++)
    //    {
    //        for (int j = 0; j < dtSheet.Columns.Count; j++)
    //        {
    //            wrdChart.Application.DataSheet.Cells[i + 2, j + 1] = dtSheet.Rows[i][j].ToString();
    //        }
    //    }

    //    wrdChart.Width = 500;
    //    //지연시간이 필요할 경우
    //    //Thread.Sleep(3000);
    //    wrdChart.Application.Quit();
    //}
    #endregion

    #endregion

    #region UI 부분(MakeSubMenu, btnResult_Click, makeDate)

    #region 서브메뉴생성 메서드
    /// <summary>
    /// 서브 매뉴 생성
    /// </summary>
    private void MakeSubMenu()
    {
        HtmlGenericControl id1 = (HtmlGenericControl)Page.FindControl("divMenu1");
        HtmlGenericControl id2 = (HtmlGenericControl)Page.FindControl("divMenu2");
        HtmlGenericControl id3 = (HtmlGenericControl)Page.FindControl("divMenu3");
        HtmlGenericControl id4 = (HtmlGenericControl)Page.FindControl("divMenu4");
        HtmlGenericControl id5 = (HtmlGenericControl)Page.FindControl("divMenu5");

        AuthMenu(CustGrade, id1, id2, id3, id4, id5);
        string loginYN = "";

        this.t_Title_Sub.InnerHtml = "";
    }
    #endregion

    #region 조회 버튼클릭 이벤트 메서드
    /// <summary>
    /// 조회 버튼클릭 이벤트 메서드
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnResult_Click(object sender, EventArgs e)
    {
        //기준월
        nowDate = this.cal_Month.Value.Substring(0, 4) + this.cal_Month.Value.Substring(5, 2);

        //Assingment Bookmark name
        AssignBookmarkName();

        CreateDoc();

        //Download path
        ShowWordMht1.FilePath = mhtFileName.ToString();
        //ShowWordMht1.FilePath = mhtFileName.ToString();
           
        UpdateProgress1.AssociatedUpdatePanelID = this.upPnlShowWord.UniqueID;
        Thread.Sleep(1000);
    }
    #endregion

    #region 북마크할당 메서드
    /// <summary>
    /// 북마크할당 메서드
    /// </summary>
    private void AssignBookmarkName()
    {
            //북마크 아이디 할당
            bookmark1 = "bm1";
            bookmark2 = "bm2";
            bookmark3 = "bm3";
            bookmark4 = "bm4";
            bookmark5 = "bm5";
            bookmark6 = "bm6";
            bookmark7 = "bm7";
    }
    #endregion

    #endregion
}

필요한 네임스페이스

System.Net, System.Net.Sockets

System.Net.Sockets.Socket 클래스의 특징

- 클라이언트 응용프로그램과 서버 응용 프로그램에서도 소켓으로 사용 가능

- 동기, 비동기 동작을 모두 사용가능

endpoint

- 네트워크 케이블의 양 끝(종단점)

- 네트워크에 대한 읽기, 쓰기를 수행

클라이언트와 서버 응용 프로그램은 소켓 연결을 통해서 통신하고 바이트 스트림을 주고 받는다. 다른 소켓으로 메시지를 보내기 위해서는 응용 플로그램을 제공하는 PC의 아이피 주소와 소프트웨어의 프로세스 식별자를 알아야 한다.

PC에서 소프트웨어 프로세스 식별자는 포트라고 하는 고유한 숫자를 사용.

따라서 응용 프로그램에서 연결의 반대편 끝에 있는 다른 소켓에 메시지를 전달하려면 상대편 IP주소와 응용 프로그램의 포트 번호를 알아야 한다.

닷넷 프레임워크에서는 소켓의 기능을 System.Net.Sockets.Socket 클래스로 제공.

인터넷을 사용하는 소켓 응용 프로그램을 작성하므로 AddressFamily.InterNetwork를 사용한다.

[소캣구성]

소켓 객체를 생성하고 사용하기 위한 Socket 클래스의 생성자

public Socket(AddressFamily addressFamily, SocketType socketType, ProtocolType protocolType)

소켓 객체의 생성자는 3가지 열거형 AddressFamily, SocketType, ProtocolType을 인자로 받으며 각 열거형은 System.Net.Sockets 네임스페이스에 정의되어 있다.

AddressFamily 열거형

- Socket 객체가 주소를 풀이하기 위해 사용하는 주소 지정 스키마를 정의.

- 여기서는 인터넷을 사용하므로 AddressFamily.InterNetWork를 사용.

SocketType 열거형

- 소켓의 종류를 지정, 가장 많이 사용되는 소켓의 종류는 SocketType.Stream

- Stream은 양방향 연결 기반 바이트 스트림을 제공.

ProtocolType 열거형

- 소켓이 통신을 하기 위해 사용하는 저수준 프로토콜의 종류를 지정.

- TCP, AddresssFamily.InterNetwork를 사용해야 함.

예) 소켓객체의 인스턴스를 생성

Socket mySocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

[원격서버에 연결하기]

Socket클래스의 Connect()를 사용하여 원격서버에 연결.(동기적 시도)

Connect() 메소드의 서명

- public void Connect( EndPoint remoteEP);

Connect() 메소드 인자

- System.Net.EndPoint 클래스의 인스턴스

- EndPoint 클래스는 추상 클래스로 네트워크 주소를 의미한다

- EndPoint 클래스의 하위 클래스는 System.Net.IPEndPoint

- Connect() 메소드를 사용할 때는 연결하려는 원격 서버의 IP 주소와 포트 번호를 포함한 IPEndPoint 객체를 인자로 사용해야 함.

IPEndPoint객체의 2가지 생성자

public IPEndPoint(long address, int port);

public IPEndPoint(IPAddress address, int port); (가장 자주 사용함)

private void MakeDataTableAndDisplay()
{
    // Create new DataTable and DataSource objects.
    DataTable table = new DataTable();

    // Declare DataColumn and DataRow variables.
    DataColumn column;
    DataRow row; 
    DataView view;

    // Create new DataColumn, set DataType, ColumnName and add to DataTable.    
    column = new DataColumn();
    column.DataType = System.Type.GetType("System.Int32");
    column.ColumnName = "id";
    table.Columns.Add(column);
 
    // Create second column.
    column = new DataColumn();
    column.DataType = Type.GetType("System.String");
    column.ColumnName = "item";
    table.Columns.Add(column);
 
    // Create new DataRow objects and add to DataTable.    
    for(int i = 0; i < 10; i++)
    {
        row = table.NewRow();
        row["id"] = i;
        row["item"] = "item " + i.ToString();
        table.Rows.Add(row);
    }
 
    // Create a DataView using the DataTable.
    view = new DataView(table);

    // Set a DataGrid control's DataSource to the DataView.
    dataGrid1.DataSource = view;
}

return int.Parse(s, NumberStyles.Integer, null);

}

public static int Parse(string s, NumberStyles style, IFormatProvider provider)
{

NumberFormatInfo info1 = NumberFormatInfo.GetInstance(provider);

NumberFormatInfo.ValidateParseStyle(style);

return Number.ParseInt32(s, style, info1);

}

public static int ToInt32(string value)
{
          if (value == null)
                    return 0;
          return int.Parse(value);

}

l         전용과 공유의 차이점 – 명명 규칙과 버전관리 정책

l         전용 어셈블리의 특징

n         배포된 응용 프로그램에 의해서만 이용될 수 있는 모듈들의 집합.

n         해당 형식들을 ‘소유하는’ 응용 프로그램만이 이 형식들을 사용할 수 있고 시스템의 다른 응용 프로그램과 공유하지 않게 한다는 것을 의미.

n         클라이언트 응용 프로그램과 동일한 디렉토리(응용 프로그램 디렉토리)나 그 하위 디렉토리에 있어야 함.

n         전용 어셈블리의 resolution과 로딩은 어셈블리가 위치한 응용 프로그램 디렉토리(bin 디렉토리)에서 일어난다. 옮겨도 실행됨.

n         삭제를 하여도 머신의 다른 응용 프로그램에는 손상을 주지 않음.

l         전용 어셈블리 프로빙(기초)

n         프로빙 – 외부 어셈블리 참조자를 정확히 상응하는 바이너리 파일에 매핑하는 과정

n         프로빙이란?

u        닷넷 런타임이 어떤 모듈의 매니페스트로부터 .assembly extern CarLibrary 라는 라인을 읽게 되면 CarLibrary.dll이라는 이름의 파일을 검색한다. 이 때 이 파일을 검색할 수 없게 된다면 *.exe 버전을 검색하게 된다. 이 두 파일이 모두 검색되지 않으면 런타임 예외를 발생시킨다. 그러나 XML 구성 파일(*.config)을 이용하게 되면 런타임이 응용 프로그램 디렉토리 밖의 다른 위치에 에서 프로브하게 할 수 있다.

l         전용 어셈블리 식별하기

n         전용 어셈블리 식별자 – 문자열 이름과 숫자 버전으로 구성.

n         문자열 이름 – 어셈블리의 매니페스트를 포함하는 바이너리 모듈의 이름에 기초해서 만들어진다.

Ex) CarLibrary.dll 어셈블리의 매니페스트

.assembly CarLibrary

{

….

.ver 1:0:454:30104 ß--- 버전 번호는 다를 수 있다.

}

어셈블리의 버전 정책은 닷넷 런타임이 어셈블리를 로딩할 때 적용하려 하지 않을 것이다. 그 이유는 이 전용 어셈블리를 알고 있는 것은 바로 해당 클라이언트 응용 프로그램밖에 없기 때문이다. 그렇기 때문에 전용 어셈블리에 대해서는 정확한 버전 검사를 할 필요가 없는 것이다.

Reference

1. Part3 .NET 어셈블리를 이용한 프로그래밍, 9장 .NET 어셈블리, C# and the .NET Platform, p.440~442

1. 닷넷 델리게이트

-         응용 프로그램 내에 있는 다른 메소드를 가리키는 객체

1.1 델리게이트가 포함하는 3가지 중요한 정보

-         델리게이트가 호출하는 메소드 이름

-         이 메소드의 인수

-         이 메소드의 반환값

1. 2 닷넷 프레임워크에서는 동기 델리게이트와 비동기 델리게이트를 이용하는 것이 가능.

2. C#에서 델리게이트 정의하기

-         delegate 키워드를 사용.

-         내부적으로 System.MulticastDelegate로부터 파생되는 봉인 클래스가 생성됨.

Ex) public delegate void PlayAcidHouse(Person theDJ, int volumn);

-         PalyAcidHouse 클래스에는 자동적으로 3개의 public 메소드가 만들어짐.

-         Invoke() : 델리게이트에게 현재 지시하고 있는 메소드를 호출할 때를 알리기 위해서 호출, C#에서 직접 호출 불가능

-         BeginInvoke(), EndInvoke() 는 비동기 호출하는데 이용

MSDN - Generic 소개

1. 제너릭 클래스와 메서드가 있다.

2. 제너릭 형식에서만 가능.

3. 재사용성, 형식 안정성, 효율성 달성이 가능.

4. 컬렉션과 컬렉션을 다루는 메서드에서 일반적으로 사용.

5. System.Collections.Generic 네임스페이스에 제너릭 기반 컬렉션 클래스가 존재.

using System;
using System.Collections.Generic;
using System.Text;

namespace VS2005
{
 //T형식 파라미터
 public class GenericClassTest<T>
 {
  //중첩된 Node 클래스도 T 제너릭
  public class Node
  {
   //T as private member data type
   private T data;
   public T Data
   {
    get { return data; }
    set { data = value; }
   }

   private Node head;
   public Node next;
   public Node Next
   {
    get { return next; }
    set { next = value; }
   }

   //중첩 Node 클래스의 생성자
   //생성자가 T를 받아서 타입을 결정
   public Node(T t)
   {
    next = null;
    Data = t;
   }
  }

  public GenericClassTest()
  {
   head = null;
  }

  public void AddHead(T t)
  {
   Node n = new Node(t);
   n.next = head;
   head = n;
  }
  public IEnumerator<T> GetEnumerator()
  {
   Node current = head;
   while(current != null)
   {
    yield return current.Data;
    current = current.Next;
   }
  }
 
 }

 public class GenericTest
 {
  public static void Main()
  {
   GenericClassTest<int> list = new GenericClassTest<int>();
   for (int i = 0; i < 10; i++ )
   {
    list.AddHead(i);
   }

   foreach (int i in list)
   {
    System.Console.Write(i + "");
   }
   System.Console.WriteLine("\nDone");
  }
 }
}

작성자 : 박종현
작성일: 2007-09-05
원문 : http://samples.gotdotnet.com/quickstart ··· xml.aspx

* 번역에 오역이 있을 수 있습니다.

XML in the .NET Framework

Extensible Markup Language (XML) 는 구조화된 데이터를 기술하기 위한 하나의 포맷을 제공하는 메타-마크업 언어이다. XML은 웹 기반의 데이터를 보여주고, 교정을 가능하게 하는 새로운 세대의 어플리케이션을 가능하게 해준다. XML은 웹 상의 데이터를 위한 공용 언어이다. XML은 어플리케이션들의 광대하고 다양한 구조화된 데이터들을 로컬 컴퓨테이션과 프리젠테이션을 위한 데스크탑으로 강력한 배포의 기회를 개발자들에게 제공한다.

System.Xml Namespace

아래는 System.Xml Namespace에서 XML 클래스들의 어법을 다룬다.

이 네임스페이스들은 파싱, 벨리데이션 그리고 XML 데이터의 교정을 위한 리더들, 라이터들의 포괄적인 집합과 World Wide Web Consortium (W3C) DOM-compliant 컴폰넌트들을 가진다.
그것은 또한 XML Path Language (XPath) 쿼리들과 and Extensible Stylesheet Language Transformations (XSLT)를 포함한다. 다음은 XML 네임스페이스내의 많은 클래스들을 포함하는 리스트 이다.

XmlTextReader 클래스는 XML 데이터를 단지 빠르게 읽고, 캐쉬되지 않는다.
XmlNodeReader 클래스는 DOM 노드의 서브트리 상단에 위치하는 XmlReader를 제공한다.
XmlValidatingReader 클래스는 DTD, XDR 그리고 XSD 스키마의 합당성 여부를 판단한다.
XmlTextWriter 클래스는 순차적으로 빠르게 XML을 추가하는데 사용한다.
XmlDocument 클래스는 W3C Document Object Model level 1 Core 와 the Core DOM Level 2를 실행한다.
XmlDataDocument 클래스는 DataSet을 지원할 수 있는 XML Document 도구를 제공한다. 구조화된 XML은 XML Document의 트리 표현이나 DataSet의 관계 표현을 통해서 보여질 수 있고 동시에 교정될 수 있다.
XPathDocument 클래스는 XSLT를 위한 XML 문서 프로세싱을 위한 빠르고 퍼포먼트한 캐쉬를 제공한다.

XPathNavigator 클래스는 네비게이션을 위한 하나의 커서 스타일 모델로써 저장보다는 W3C XPath 1.0 data 모델을 제공한다.
XslTransform 클래스는 XML문서들을 변형하기 위한 XSLT 프로세서로 W3C XSLT 1.0 이라는 특정한 컴파일러를 제공한다.
XmlSchema 객체 모델 클래스들은 W3C XSD 규약의 직접적으로 영향을 미치는 클래스들의 집합을 찾아가도록 도와주는 기능을 제공한다.
XmlSchemaCollection 클래스는 XDR 와 XSD 스키마들의 라이브러리들을 제공한다. 이 스키마들, 메모리에 캐쉬된 XmlValidatingReader를 위해 파서-타임 유효성 검증을 빠르게 도와준다.

작성자 : 박종현
작성일 : 2007-09-05
출처 : http://samples.gotdotnet.com/quickstart ··· ile.aspx


XML Data

Overview of XML

XML in the .NET Framework

Extensible Markup Language (XML) 는 구조화된 데이터를 기술하기 위한 하나의 포맷을 제공하는 메타-마크업 언어이다. XML은 웹 기반의 데이터를 보여주고, 교정을 가능하게 하는 새로운 세대의 어플리케이션을 가능하게 해준다. XML은 웹 상의 데이터를 위한 공용 언어이다. XML은 어플리케이션들의 광대하고 다양한 구조화된 데이터들을 로컬 컴퓨테이션과 프리젠테이션을 위한 데스크탑으로 강력한 배포의 기회를 개발자들에게 제공한다.

System.Xml Namespace

아래는 System.Xml Namespace에서 XML 클래스들의 어법을 다룬다.

이 네임스페이스들은 파싱, 벨리데이션 그리고 XML 데이터의 교정을 위한 리더들, 라이터들의 포괄적인 집합과 World Wide Web Consortium (W3C) DOM-compliant 컴폰넌트들을 가진다.

그것은 또한 XML Path Language (XPath) 쿼리들과 and Extensible Stylesheet Language Transformations (XSLT)를 포함한다. 다음은 XML 네임스페이스내의 많은 클래스들을 포함하는 리스트 이다.

XmlTextReader 클래스는 XML 데이터를 단지 빠르게 읽고, 캐쉬되지 않는다.

XmlNodeReader 클래스는 DOM 노드의 서브트리 상단에 위치하는 XmlReader를 제공한다.

XmlValidatingReader 클래스는 DTD, XDR 그리고 XSD 스키마의 합당성 여부를 판단한다.

XmlTextWriter 클래스는 순차적으로 빠르게 XML을 추가하는데 사용한다.

XmlDocument 클래스는 W3C Document Object Model level 1 Core 와 the Core DOM Level 2를 실행한다.

XmlDataDocument 클래스는 DataSet을 지원할 수 있는 XML Document 도구를 제공한다. 구조화된 XML은 XML Document의 트리 표현이나 DataSet의 관계 표현을 통해서 보여질 수 있고 동시에 교정될 수 있다.

XPathDocument 클래스는 XSLT를 위한 XML 문서 프로세싱을 위한 빠르고 퍼포먼트한 캐쉬를 제공한다.

XPathNavigator 클래스는 네비게이션을 위한 하나의 커서 스타일 모델로써 저장보다는 W3C XPath 1.0 data 모델을 제공한다.

XslTransform 클래스는 XML문서들을 변형하기 위한 XSLT 프로세서로 W3C XSLT 1.0 이라는 특정한 컴파일러를 제공한다.

XmlSchema 객체 모델 클래스들은 W3C XSD 규약의 직접적으로 영향을 미치는 클래스들의 집합을 찾아가도록 도와주는 기능을 제공한다.

XmlSchemaCollection 클래스는 XDR 와 XSD 스키마들의 라이브러리들을 제공한다. 이 스키마들, 메모리에 캐쉬된 XmlValidatingReader를 위해 파서-타임 유효성 검증을 빠르게 도와준다.

작성자: 박종현
작성일: 2007-09-05
출처: http://samples.gotdotnet.com/quickstart ··· ile.aspx



XML Readers and Writers

Read XML from a file

파일에서 XML을 읽는 방법

XmlReader 클래스는 XML 파싱을 제공하는 API 이다.

XmlTextReader는 바이트 스트림들을 핸들하기 위해 디자인된 도구이다.

일반적으로, 당신이 DOM Overhead가 없는 가공되지 않은 Xml 데이터를 읽기를 원한다면 XmlTextReader를 사용한다.

아래는 books.xml 이다.

다음은 이것을 읽어들이는 C#코드이다.

XML파일을 읽기 위해 2가지의 네임스페이스를 추가한다.

아래의 코드에서는 XML의 부모 노드 정보만 가져온다.

이것의 출력 결과는 아래와 같다.

XmlNodeType은 XmlReader 클래스에 의해 의존적이고 리턴된다.

XmlTextReader 클래스는 XmlNodeType인 Document, Documentfragment, Entity, EndEntity 그리고 Notation 노드를 리턴한다.

그럼 이제 books.xml 이 가지는 모든 엘리먼트와 어트리뷰트를 읽어보도록 하겠습니다.

출력 결과

using System;

using System.Data;

using System.Configuration;

using System.Collections;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Web.UI.HtmlControls;

using System.Xml;

public partial class AboutOnlyXML_MakeXMLFile : System.Web.UI.Page

{

    protected void Page_Load(object sender, EventArgs e)

    {

                                   //xml문서 생성을 위해 xmlTextWriter인스턴스 객체를 생성한다.

                                   XmlTextWriter xmlTxtWriter = new XmlTextWriter(@"D:\wwwroot\Pilot_Web\AboutOnlyXML\NewBooks.xml", null);

                                   //XML 문서를 생성할 때 자식요소에 따라 들여쓰기를 한다.

                                   xmlTxtWriter.Formatting = Formatting.Indented;

                                   //XML선언을 작성한다.

                                   xmlTxtWriter.WriteStartDocument(false);

                                   //DocType을 생성한다.

                                   xmlTxtWriter.WriteDocType("bookstore", null, "books.dtd", null);

                                   //주석을 만든다.

                                   xmlTxtWriter.WriteComment("This file represents another fragment of a book store inventory database");

                                   //시작 엘리먼트를 생성한다.

                                   xmlTxtWriter.WriteStartElement("book", null);

                                   //시작 엘리먼트의 어트리뷰트를 작성한다.

                                   xmlTxtWriter.WriteAttributeString("genre", "autobiography");

                                   xmlTxtWriter.WriteAttributeString("publicationdate", "1979");

                                   xmlTxtWriter.WriteAttributeString("ISBN", "0-7356-0562-9");

                                   //시작 엘리먼트 내부에 또 다른 엘리먼트와 내용을 생성한다.

                                   xmlTxtWriter.WriteElementString("title", null, "The Autobiography of Mark Twain");

                                   //시작 엘리먼트 내부에 엘리먼트만 생성한다.

                                   xmlTxtWriter.WriteStartElement("Author", null);

                                   //시작 엘리먼트 내부의 엘리먼트에 자식 엘리먼트2개를 생성한다.

                                   xmlTxtWriter.WriteElementString("first-name", "Mark");

                                   xmlTxtWriter.WriteElementString("last-name", "Twain");

                                   //엘리먼트를 종료한다.

                                   xmlTxtWriter.WriteEndElement();

                                   //시작 엘리먼트 하위에 자식 엘리먼트를 생성한다.

                                   xmlTxtWriter.WriteElementString("price", "7.99");

                                   //시작 엘리먼트를 종료한다.

                                   xmlTxtWriter.WriteEndElement();

                                   xmlTxtWriter.Flush();

                                   xmlTxtWriter.Close();

    }

}

<Window ... xmlns:src="clr-namespace:ApplicationNameSpace">
  ...
  <!-- Binding Source -->
  <Window.Resources>
    <src:Person x:Key="myDataSource" PersonName="Joe"/>
  </Window.Resources>
  ...
  <!-- Binding Target -->
  <TextBlock Text="{Binding Source={StaticResource myDataSource}, Path=PersonName}" />
  ...
</Window>

Person객체의 PersonName 프로퍼티는 Joe라는 값을 가지고 있고, TextBlock의 Text 프로퍼티는 그것의 바인드를 서술하고 있습니다.

WPF의 데이터바인딩은 유효성, 정렬, 그룹핑 등과 같은 복합적 서비스를 제공합니다.
또한 데이터바인딩은 표준 컨트롤에 쉽게 바인드 되고, 사용자에게 보여지며, 커스터마이즈 할 수 있으며, 데이터 템플레이팅을 지원하는 인프라스트럭처를 제공합니다.

Appearance
WPF를 통해서 우리는 어플리케이션을 빌드하기 위한 컨트롤과 공통 엘리먼트 집합을 만날 수 있으며 나아가 확장, 커스터마이징, 재사용 가능한 엘리먼트와 컨트롤들 또한 만날 수 있습니다. 이것을 통해 우리는 새로운 컨트롤이나 엘리먼트를 쉽게 커스텀 컨트롤을 만들수 있습니다.
나중에 차차 더 많은 걸 배울 수 있을 겁니다.

리소스
어플리케이션내의 멀티 컨트롤은 객체의 타입과 값, 폰트, 배경, 컬러, 컨트롤 템플릿, 데이터 템플릿, 그리고 스타일을 공유합니다. WPF는 객체와 값을 define하기 위해 UI와 같이 잘 알려진 인프라스트럭처를 제공합니다.

다음의 예는 두 개의 버튼 컨트롤이 배경을 공유하는 것을 보여줍니다.

<Window
  xmlns="http://schemas.microsoft.com/winfx/2006 ··· entation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <Window.Resources>
    <SolidColorBrush x:Key="defaultBackground" Color="Red" />
  </Window.Resources>
  < StackPanel>
    <Button Background="{StaticResource defaultBackground}">One Button</Button>
    <Label Background="{StaticResource defaultBackground}">One Label</Label>
  </StackPanel>
</Window>

리소스는 특정 컨트롤, 특정 페이지 또는 윈도우 폼 상의 모든 컨트롤이나 어플리케이션의 모든 컨트롤로 범위를 한정할 수 있습니다. 이러한 것들을 이용하여 우리는 객체나 그 값을 쉽게 재사용할 수 있습니다.

스타일
스타일은 제품을 규격화 하기 위해 사용하는 어플리케이션, 문서, UI 디자이너가 가지는 WPF에서 자주 등장하는 여러 특징들 중의 하나 입니다.
디자이너는 application-by-application에 기초해서 확장을 할 수 있습니다.
WPF는 스타일 엘리먼트 모델을 제공하며 아래의 예제는 TextBlock에 사용될 배경색을 설정하는 예제입니다.

<Style TargetType="{x:Type Button}">
  <Setter Property="Background" Value="Yellow"/>
</Style>