Showmeself

A more detailed explanation of the code is already presented in the
chapter.
*/
using System;
using System.Windows.Forms;
using Microsoft.VisualStudio.Tools.Applications.Runtime;
using Outlook = Microsoft.Office.Interop.Outlook;
using Office = Microsoft.Office.Core;
using System.Runtime.InteropServices;
using System.Reflection;

namespace AllSamples
{
    public partial class ThisApplication
    {
        private void Listing_5_1()
        {
            if (this.Session.Folders.Count > 0)
            {
                Outlook.MAPIFolder folder = this.Session.Folders[1];
                {
                    MessageBox.Show("The " + folder.Name + " folder contains " + folder.Items.Count + " items.");
                }
            }
        }
        private void Listing_5_2()
        {
            Outlook.MAPIFolder folder = this.Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderContacts);
            Outlook.Explorer explorerWindow = this.Explorers.Add(folder, Outlook.OlFolderDisplayMode.olFolderDisplayNormal);
            explorerWindow.Activate();
        }
        private void Listing_5_3()
        {
            Outlook.Application ol = new Microsoft.Office.Interop.Outlook.Application();
            Outlook.MailItem NewMail = ol.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olMailItem) as Outlook.MailItem;
            Outlook.Inspector inspectorWindow = this.Inspectors.Add(NewMail);
            inspectorWindow.Activate();
        }
        //to run this example, add a valid email address in the to field
        private void Listing_5_4()
        {
            CreateAndSendEmail();
        }
        public void CreateAndSendEmail()
        {
            Outlook.Application ol = new Microsoft.Office.Interop.Outlook.Application();
            Outlook.MailItem NewMail = ol.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olMailItem) as Outlook.MailItem;
            NewMail.Subject = "This is my email subject";
            NewMail.To = "Add a valid email address here";
            NewMail.Importance = Microsoft.Office.Interop.Outlook.OlImportance.olImportanceNormal;
            NewMail.HTMLBody = "This <u>is</u> truly <b>amazing</b>";
            NewMail.BodyFormat = Microsoft.Office.Interop.Outlook.OlBodyFormat.olFormatHTML;
            NewMail.Send();
        }
        private void Listing_5_5()
        {
            BlockAttachments();
        }
        private void BlockAttachments()
        {
            Outlook.MAPIFolder inbox = Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);

            if (inbox.Items.Count > 0)
            {
                foreach (object item in inbox.Items)
                {
                    Outlook.MailItem virus = item as Outlook.MailItem;
                    if (virus != null)
                    {
                        if (virus.Attachments != null)
                        {
                            System.Collections.ArrayList forbidden = new System.Collections.ArrayList(virus.Attachments.Count);
                            foreach (Outlook.Attachment attachObject in virus.Attachments)
                            {
                                object obj = attachObject.MAPIOBJECT;
                                if (obj != null)
                                {
                                    attachObject.Delete();
                                    forbidden.Add(attachObject.DisplayName);
                                }
                            }
                            if (forbidden.Count > 0)
                            {
                                MessageBox.Show("Some emails were blocked because they contain attachments");
                            }
                        }
                    }
                }
            }
        }
        private void Listing_5_6()
        {
            //creat the outlook appointment
            Outlook.Application appItem = new Microsoft.Office.Interop.Outlook.Application();
            Outlook.AppointmentItem appointment = appItem.CreateItem(Outlook.OlItemType.olAppointmentItem) as Outlook.AppointmentItem;

            //set up some custom features
            appointment.Subject = "This is my new appointment subject";
            appointment.Body = "This is my new appointment body";
            appointment.AllDayEvent = true;
            appointment.BusyStatus = Outlook.OlBusyStatus.olBusy;
            appointment.Start = DateTime.Now;
            appointment.End = DateTime.Now.AddMinutes(30);
            appointment.ReminderSet = true;
            appointment.Importance = Microsoft.Office.Interop.Outlook.OlImportance.olImportanceHigh;

            //activate
            appointment.Save();
        }
        //to fire this code, we first need to subscribe tot he newinspector event
        //after the application is run, trigger a newinspector object by double-clicking
        //on an email item, or a contact item etc.
        private void Listing_5_7()
        {
            Inspectors.NewInspector += new Microsoft.Office.Interop.Outlook.InspectorsEvents_NewInspectorEventHandler(Inspectors_NewInspector);
        }
        void Inspectors_NewInspector(Microsoft.Office.Interop.Outlook.Inspector Inspector)
        {
            if (this.Inspectors.Count > 0)
            {
                object item = this.Inspectors[1].CurrentItem;
                Type type = item.GetType();
                string propertyMapper = type.InvokeMember("MessageClass",
                BindingFlags.Public | BindingFlags.GetField | BindingFlags.GetProperty, null, item, new object[] { }).ToString();
                if (propertyMapper == "IPM.Note")
                {
                    Outlook.MailItem note = item as Outlook.MailItem;
                    if (note != null)
                    {
                        if (!note.IsConflict)
                        {
                            Outlook.Conflicts conflicts = note.Conflicts;
                            if (conflicts.Count < 1)
                            {
                                string subject = note.To;
                                MessageBox.Show("The email is addressed to " + subject);
                            }
                            System.Runtime.InteropServices.Marshal.ReleaseComObject(note);
                        }
                    }
                }
            }
        }
        private void Listing_5_8()
        {
            DeleteAppointments("This is my new appointment subject");
        }
        public void DeleteAppointments(string item)
        {
            Outlook.MAPIFolder oCalendar = Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderCalendar);
            string retVal = string.Empty;

            foreach (Outlook.AppointmentItem oResult in oCalendar.Items)
            {
                if (oResult != null)
                {
                    retVal = (string)oResult.GetType().InvokeMember("Subject", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.GetProperty, null, oResult, null, null);
                    if (retVal == item)
                    {
                        oResult.Delete();
                    }
                }
            }
        }
        //the code below demonstrates adding appointments. You will need to replace the
        //i.ToString() with valid attendees
        private void Listing_5_9()
        {
            //creat the outlook appointment
            Outlook.Application appItem = new Microsoft.Office.Interop.Outlook.Application();
            Outlook.AppointmentItem appointment = appItem.CreateItem(Outlook.OlItemType.olAppointmentItem) as Outlook.AppointmentItem;

            Outlook.Recipients attendees = appointment.Recipients;
            //add meeting participants
            for (int i = 0; i < 10; i++)
            {
                Outlook.Recipient developer = attendees.Add(i.ToString());
                developer.Type = (int)Outlook.OlMeetingRecipientType.olRequired;
            }
            //activate
            appointment.Send();
        }
        private void Listing_5_10()
        {
            Outlook.Application ol = new Microsoft.Office.Interop.Outlook.Application();
            Outlook.NoteItem NewNote;
            //Create a new note
            NewNote = ol.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olNoteItem) as Outlook.NoteItem;
            NewNote.Body = "This is my new note body";
            NewNote.Categories = "Memo";
            NewNote.Display(false);
        }
        private void Listing_5_11()
        {
            Outlook.Application ol = new Microsoft.Office.Interop.Outlook.Application();
            Outlook.NoteItem NewNote;
            //Create a new note
            NewNote = ol.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olNoteItem) as Outlook.NoteItem;
            object modal = true;
            NewNote.Body = "Holiday 2morrow";
            NewNote.Categories = "Business";
            NewNote.Height %= 2;
            NewNote.Color = Outlook.OlNoteColor.olBlue;
            NewNote.Display(modal);
        }
        private void Listing_5_12()
        {
            Outlook.MAPIFolder itemsBox = Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderDeletedItems);
            if (itemsBox.Items.Count > 0)
            {
                foreach (object item in itemsBox.Items)
                {
                    Outlook.MailItem oItem = item as Outlook.MailItem;
                    if (oItem != null)
                    {
                        //code to process items
                    }
                }
            }
        }
        private void Listing_5_13()
        {
            GetInfoFromAddressBook("contact", "enter search name here");
        }
        private Outlook.AddressEntry GetInfoFromAddressBook(string contact, string name)
        {
            if (name == null || name.Trim().Length == 0)
                return null;
            if (contact == null || contact.Trim().Length == 0)
                contact = "Contacts";

            contact = contact.Trim();
            name = name.Trim();

            if (Session.AddressLists != null && Session.AddressLists.Count > 0)
            {
                Outlook.AddressLists addressLists = Session.AddressLists as Outlook.AddressLists;
                foreach (Outlook.AddressList address in addressLists)
                {
                    if (address.Name.Trim() == contact)
                    {
                        foreach (Outlook.AddressEntry entry in address.AddressEntries)
                        {
                            if (entry.Name.Trim() == name)
                            {
                                return entry;
                            }
                        }
                    }
                }
            }
            return null;
        }
        private void Listing_5_14()
        {
            this.MAPILogonComplete += new Microsoft.Office.Interop.Outlook.ApplicationEvents_11_MAPILogonCompleteEventHandler(ThisApplication_MAPILogonComplete);
        }
        void ThisApplication_MAPILogonComplete()
        {
            MessageBox.Show("Welcome " + this.GetNamespace("MAPI").CurrentUser.Name.ToString());
        }
        //this routine searches the inbox folder for emails matching the subject "virus"
        private void Listing_5_15()
        {
            SearchRoutine("virus");
        }
        public void SearchRoutine(string searchToken)
        {
            Outlook.MAPIFolder oInbox = Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);
            int count = oInbox.Items.Count;
            string retVal = string.Empty;

            foreach (object oResult in oInbox.Items)
            {
                retVal = (string)oResult.GetType().InvokeMember("Subject", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.GetProperty, null, oResult, null, null);
                if (retVal == searchToken)
                {
                    MessageBox.Show("Found a suspicious item");
                }
            }
        }
        private void Listing_5_16()
        {
            //OutlookSearch.Properties.
            Outlook.MAPIFolder oInbox = Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);
            object oResult = oInbox.Items.Find(@"[Subject] = ""virus""");

            if (oResult != null)
            {
                Outlook.MailItem data = (Outlook.MailItem)oResult;
                if (data != null)
                {
                }
            }
        }
        private void Listing_5_17()
        {
            Outlook.MAPIFolder oInbox = Session.GetDefaultFolder(Outlook.OlDefaultFolders.olFolderInbox);
            object oResult = oInbox.Items.Find(@"[Subject] = ""virus""");
            do
            {
                oResult = oInbox.Items.FindNext();
            } while (oResult != null);

            Outlook.MailItem data;
            if (oResult != null)
            {
                MessageBox.Show("Found");
                data = (Outlook.MailItem)oResult;
            }
        }
        private void Listing_5_18()
        {
            string scope = @"’Inbox’";
            string filter = @"""subject"" LIKE ‘%vir%’";
            string tag = "uniqueTag";
            object subFolders = false;

            this.AdvancedSearchComplete += new Microsoft.Office.Interop.Outlook.ApplicationEvents_11_AdvancedSearchCompleteEventHandler(ThisApplication_AdvancedSearchComplete);
            this.AdvancedSearch(scope, filter, subFolders, tag);
        }
        //event handler code. Notice that this code is different from the text in the book
        //the reason for this change is that the advancedsearchcomplete method executes on
        //a separate thread that isn’t allowed to manipulate GUI objects that are part of
        //Outlook. The access simply causes a run-time exception. The code has been simplified
        //to show an appropriate message.
        void ThisApplication_AdvancedSearchComplete(Microsoft.Office.Interop.Outlook.Search SearchObject)
        {
            if (SearchObject != null)
            {
                MessageBox.Show("A piece of mail with subject ‘virus’ was found");
            }
        }
        //to run this example, add a valid email address in the to field
        private void Listing_5_19()
        {
            Outlook.MailItem NewMail = this.CreateItem(Microsoft.Office.Interop.Outlook.OlItemType.olMailItem) as Outlook.MailItem;
            NewMail.Subject = "This is my email subject";
            NewMail.To = "vapordan@hotmail.com";
            NewMail.Send();
        }
        Office.CommandBar NewCommandBar;
        Office.CommandBarButton NewCBarButton;
        Office.CommandBars newCommandBar;
        Outlook.Explorer explorer;
        private void Listing_5_20()
        {
            explorer = this.ActiveExplorer();
            newCommandBar = explorer.CommandBars;

            object val = false;
            NewCommandBar = newCommandBar.Add("myButton", Office.MsoBarPosition.msoBarTop, false, false);
            NewCBarButton = (Office.CommandBarButton)NewCommandBar.Controls.Add(Office.MsoControlType.msoControlButton, missing, missing, missing, false);
            NewCBarButton.Caption = "button1";
            NewCBarButton.FaceId = 563;
            NewCommandBar.Visible = true;
            NewCBarButton.Visible = true;
            NewCBarButton.TooltipText = "My new button1";
            NewCBarButton.Click += new Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler(NewCBarButton_Click);
        }

        void NewCBarButton_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault)
        {
            MessageBox.Show("Hello, world!");
        }
        private void Listing_5_21()
        {
            Outlook.Explorer explorer = this.ActiveExplorer();
            Office.CommandBars newCommandBar = explorer.CommandBars;

            //do not replicate command bar objects
            foreach (Office.CommandBar cmdBar in newCommandBar)
            {
                if (cmdBar.Name.Equals("ShortcutBar"))
                {
                    cmdBar.Delete();
                    break;
                }
            }
        }
        Office.CommandBar menubar;
        Office.CommandBarPopup cmdBarControl;
        Office.CommandBarButton menuCommand;
        private void Listing_5_22()
        {
            // Add the menu.
            menubar = this.ActiveExplorer().CommandBars.ActiveMenuBar;
            cmdBarControl = (Office.CommandBarPopup)menubar.Controls.Add(
            Office.MsoControlType.msoControlPopup, missing, missing, menubar.Controls.Count, true);
            if (cmdBarControl != null)
            {
                cmdBarControl.Caption = "&Add-in Tools";
                // Add the menu command.
                menuCommand = (Office.CommandBarButton)cmdBarControl.Controls.Add(
                Office.MsoControlType.msoControlButton, missing, missing, missing, true);
                menuCommand.Caption = "&Word Count…";
                menuCommand.Tag = DateTime.Now.ToString();
                menuCommand.Click += new Microsoft.Office.Core._CommandBarButtonEvents_ClickEventHandler(menuCommand_Click);
            }
        }
        void menuCommand_Click(Microsoft.Office.Core.CommandBarButton Ctrl, ref bool CancelDefault)
        {
            MessageBox.Show("Hello, World!");
        }
        //to run this example, pass in the string identifier of the bar to be removed
        private void Listing_5_23()
        {
            RemoveMenubar("statusbar");
        }
        private void RemoveMenubar(string menuTitle)
        {
            //remove the menu
            try
            {
                Office.CommandBarPopup foundMenu = (Office.CommandBarPopup)
                    this.ActiveExplorer().CommandBars.ActiveMenuBar.
                    FindControl(Office.MsoControlType.msoControlPopup,
                    missing, menuTitle, true, true);
                if (foundMenu != null)
                {
                    foundMenu.Delete(true);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }

        //the following start up event handler is designed to call the code for each
        //example in chapter 5. To run these examples, uncomment the appropriate function
        private void ThisApplication_Startup(object sender, System.EventArgs e)
        {
            //Listing_5_1();
            //Listing_5_2();
            //Listing_5_3();
            //Listing_5_4();
            //Listing_5_5();
            //Listing_5_6();
            //Listing_5_7();
            //Listing_5_8();
            //Listing_5_9();
            //Listing_5_10();
            //Listing_5_11();
            //Listing_5_12();
            //Listing_5_13();
            //Listing_5_14();
            //Listing_5_15();
            //Listing_5_16();
            //Listing_5_17();
            //Listing_5_18();
            //Listing_5_19();
            //Listing_5_20();
            //Listing_5_21();
            //Listing_5_22();
            //Listing_5_23();
        }

        private void ThisApplication_Shutdown(object sender, System.EventArgs e)
        {
        }

        #region VSTO generated code

        /// <summary>
        /// Required method for Designer support – do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        private void InternalStartup()
        {
            this.Startup += new System.EventHandler(ThisApplication_Startup);
            this.Shutdown += new System.EventHandler(ThisApplication_Shutdown);
        }

        #endregion
    }

在程序间通信

过去几年来，我们一直处于 Microsoft 为 Web 服务所发起的营销宣传的包围之中，但是它已经使人对不同的程序间的通信技术产生了错误的印象。Web 服务对于某些场合确实很好，但其他一些技术也是值得考虑的。

其中最重要的一种技术是 .NET 远程处理，当您在连接的两端都使用 .NET 时，该技术将很有用。您可以以透明方式使用任何类型，而不会被限制为 SOAP 类型。

简单的远程处理示例

作为示例，我将为媒体播放机程序生成一个远程控件。我将在一台计算机上运行该播放机程序，而从另一台计算机上远程控制该程序。

第一步是定义一个接口，以描述可以做的事情。服务器端对象将实现该接口，而客户端将基于该接口执行调用。严格说来，我不需要做这项工作。如果我在客户端使用服务器端类型，.NET 远程处理仍然可以很好地工作，但如果我那样做的话，客户端将需要访问服务器端对象，而这样并不好。所以，我将定义一个接口，然后将其放在类库对象中：

namespace RemotingLibrary
{
   public interface IPlayer
   {
      void Play();
      void Pause();
      string GetCurrentSong();
   }
}

下一步，我将在服务器上工作。我知道我需要一个对象来实现该接口，因此我从编写该对象开始。

using System;
using System.Runtime.Remoting;
using RemotingLibrary;

namespace RemotingServer
{
   public class MyRemote: MarshalByRefObject, IPlayer
   {
      public MyRemote()
      {
      }

      public void Pause()
      {
         // TODO:  Add MyRemote.Pause implementation
      }

      public void Play()
      {
         // TODO:  Add MyRemote.Play implementation
      }

      public string GetCurrentSong()
      {
         return "Devo - Girl U Want";
      }
   }
}

我已经为 GetCurrentSong() 植入了一些测试代码，从而可以检查我所得到的结果。注意，MyRemote 类型是从 MarshalByRefObject 派生的。要想从远程处理机制中使用对象，这是其中一项要求。这一点比较遗憾，因为这意味着我不能对该对象使用我自己的基类。

接下来，需要编写服务器代码。我将稍经修改的 MSDN 示例作为服务器代码的基础。

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;

namespace RemotingServer
{
   class Server
   {
      public static void Main()
      {
         TcpChannel m_TcpChan = new TcpChannel(9999);
         ChannelServices.RegisterChannel(m_TcpChan);
         RemotingConfiguration.RegisterWellKnownServiceType(
               typeof(MyRemote),
               "MyRemote", WellKnownObjectMode.SingleCall);
         System.Console.WriteLine("Press ENTER to quit");
         System.Console.ReadLine();
      }
   }
}

这些代码似乎要比想象中的简单。在端口 9999 上打开了一个 TCP 信道，注册该信道，然后将我的类型注册为可以远程使用的类型。完成这一工作后，运行库将为我处理所有事情，所以我只须静静地等待。

要编写的最后一部分代码是客户端代码。

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using RemotingLibrary;

namespace RemotingClient
{
   class RemoteClient
   {
      public static void Main()
      {
         TcpChannel tcpChan = new TcpChannel();
         ChannelServices.RegisterChannel(tcpChan);
         IPlayer player = (IPlayer)
            Activator.GetObject(typeof(IPlayer),
            "tcp://localhost:9999/MyRemote");
         Console.WriteLine(player.GetCurrentSong());
      }
   }
}

该类引用了我在前面创建的接口库。它创建了一个 TcpChannel 并将其注册，但不是在特定端口上创建。然后，它使用 Activator 类连接到远程对象，调用 GetCurrentSong()，并写出返回值。完整示例位于 RemotingToAType 子目录中。

如果我愿意，我可以通过更改到 http 信道，将我的示例转换成 Web 服务的样子。该示例位于 RemoteToATypeSoap 子目录中。您可以通过向字符串末尾添加“?wsdl”，将该服务器添加为 Web 引用，那样它就能像任何其他 Web 服务一样工作。不过，在 MSDN 中有一条重要的注意事项，声明虽然这对 WSDL 有效，但无法创建 XSD，因而可能无法对将来的工具起作用。

这是一个很不错的示例，尽管实际上它并没有让我向目标前行多少，因为所创建的对象与正在运行的应用程序没有任何联系。我希望远程控制服务器上正在运行的实例，而不是刚刚创建的实例。换一种说法，就是我不希望这是一个无状态模型。

远程控制实例

在我编写第一个版本后，我开始研究以便搞清楚如何对一个实例做同样的事情。我试图查找名为 RegisterInstance 的例程，或者与此类似的东西，但我的搜索失败了。

在使用 Google 进行了一番千辛万苦的搜索之后，我发现了一个这样的例程，但它的名称为“Marshal”。这个名称在我的文章中不是太好，因为它与我要完成的工作没有任何关系，但既然我知道了这个例程，我就可以修改我的代码。为此，我需要对 Server 类进行一些小的改动：

      public static void Main()
      {
         MyRemote myRemote = new MyRemote("The Scorpions - Always Somewhere");
         TcpChannel m_TcpChan = new TcpChannel(9999);
         ChannelServices.RegisterChannel(m_TcpChan);
         RemotingServices.Marshal(myRemote, "MyRemote");
         System.Console.WriteLine("Press ENTER to quit");
         System.Console.ReadLine();
      }

在这些代码中，我创建了 MyRemote 类的一个实例，然后使用 Marshal 注册了该实例。我还修改了 MyRemote 类，使它采用歌曲名称作为参数，这只是为了表明我确实在与该实例进行通信。

这些代码非常不错，简单并且有效，它们位于 RemotingToAnInstance 目录中。该示例仅仅涉及到远程处理技术的一些粗浅内容，实际上，在使用什么样的信道、使用什么样的安全性以及何时执行身份验证等方面都具有相当大的灵活性。如果使用 ASP.NET 作为宿主，其中大多数事情都更加容易做到。

首先，创建一个安装和部署项目。步骤如下：
1．在"解决方案资源管理器"中的解决方案中添加一个新项目。
用鼠标右键单击解决方案，在弹出的菜单中选择"添加"－>"新建项目"。在打开的对话框中选择"安装和部署项目"，并选择"Web安装项目"模板。在输入项目名称后，点击"确定"按钮，将新项目添加到解决方案中。
2．将项目的输出添加到安装和部署项目中。
 添加完安装和部署项目后，vs.net2003 IDE会自动打开一个名为"文件系统"的管理器。用鼠标右键单击此管理器右边树型结构中的"Web应用程序文件夹"，在弹出的菜单中选择"添加"－>"项目输出"。在弹出的对话框中，选择"项目"（这时只有一个，就是你的web应用程序项目），然后在下面的列表中选择"主输出"和"内容文件"两项（可以复选），接着在"配置"中选择"Release .NET"，点击"确定"按钮。

经过上面两个步骤，一个基本的安装和部署程序就制作完成了，将此项目编译后就得到了一个Web安装程序包。

然而，在很多的情况下，我们做的Web应用程序都要使用到数据库，能不能在安装程序的同时也将数据库一起安装呢？答案是肯定的。那该怎么做呢？这个问题李洪根先生已经解决了，具体内容可以参看下面的文章
http://blog.csdn.net/lihonggen0/archive/2004/05/17/13654.aspx
在李洪根先生的这篇文章中详尽的介绍了安装程序的制作和如何同时安装数据库。在此大致叙述如下：
1．新建一个类库项目，删除自动生成的Class.cs，重新添加一个新项。鼠标右键此项目，在弹出的菜单中选择"添加"－>"添加新项"，在弹出的对话框中选择"安装程序类"。
2．创建一个自定义的安装对话框。鼠标右键点击"解决方案资源管理器"中的安装和部署项目，在弹出的菜单中选择"视图"－>"用户界面"。在打开的"用户界面"管理器中，鼠标右键点击"启动"，在弹出的菜单中选择"添加对话框"。在打开的对话框中选择"文本框（A）"。选择"文本框（A）"，在属性中，依次设置含Property属性为CUSTOMTEXT1，CUSTOMTEXT2，CUSTOMTEXT3，CUSTOMTEXT4。
3．创建自定义操作。鼠标右键点击"解决方案资源管理器"中的安装和部署项目，在弹出的菜单中选择"视图"－>"自定义操作"。在打开的"自定义操作"管理器中，鼠标右键点击"安装"，在弹出的菜单中选择"添加自定义操作"。在打开的对话框中，在"查找范围"中选择"Web应用程序文件夹"，选择下面列表中的"主输出来自Install1（活动）"（Install1是"安装程序类"所在的项目名。如果列表中没有，可以用上面提到的"将项目的输出添加到安装和部署项目中"的方法添加）。然后在"自定义操作"管理器中选择刚添加的内容，在属性窗口中设置CustomActionData属性/dbname=[CUSTOMTEXT1] /server=[CUSTOMTEXT2] /user=[CUSTOMTEXT3] /pwd==[CUSTOMTEXT4] /targetdir="[TARGETDIR]\"
注意：每个设置内容以/分隔，且以空格分开。
4．在此类中重写Install方法，并添加下面的代码
string strConn=String.Format("data source={0};user id={1};password={2};",this.Context.Parameters["server"],this.Context.Parameters["user"],this.Context.Parameters["pwd"]);
this.ExecuteSQL(strConn,"master","CREATE DATABASE "+this.Context.Parameters["dbname"]);

System.Diagnostics.Process pSQL=new System.Diagnostics.Process();
pSQL.StartInfo.FileName="osql.exe";
pSQL.StartInfo.Arguments=String.Format(" -U {0} -P {1} -d{2} -i {3}db.sql",this.Context.Parameters["user"],this.Context.Parameters["pwd"], this.Context.Parameters["dbname"],this.Context.Parameters["targetdir"]);
pSQL.StartInfo.WindowStyle=System.Diagnostics.ProcessWindowStyle.Hidden;
pSQL.Start();
pSQL.WaitForExit();
pSQL.Close();
这样，编译后的安装程序就可以连数据库一起安装了。

安装数据库的问题解决了，还有一个问题，那就是要使ASP.NET程序运行，一个重要的条件就是目标计算机上必须有.NET框架，那能不能在安装程序时也一同将.NET框架一块安装了呢？答案还是肯定的。具体可以参看
http://www.microsoft.com/china/MSDN/library/netFramework/netframework/Nfdnnetdepvsredistdeploy1_1.mspx
在这篇文章中提到了几种不同的方法重新分发.NET框架，其中最简单的一种应该算是使用VS.NET2003了。大致的步骤如下：
1．安装VS.NET框架引导程序插件。这个插件可以从微软的网站上下载，下载地址如下：
http://www.microsoft.com/downloads/details.aspx?familyid=627921a0-d9e7-43d6-a293-72f9c370bd19&displaylang=en
2．在"解决方案资源管理器"中，用鼠标右键单击安装和部署项目，在弹出的菜单中选择"视图"－>"启动条件"，打开"启动条件"管理器。
3．在"启动条件"管理器中，右键点击"目标计算机上的要求"，在弹出的的菜单中选择"添加注册表启动条件"。你会发现在"搜索目标计算机"中多了一项"搜索 RegistryEntry1"，在"启动条件"中多了一项"Condition1"。
4．选择"搜索 RegistryEntry1"，在"属性"对话框中填写如下内容：
Property：MDACSEARCH
RegKey：Software\Microsoft\DataAccess
Root：vsdrrHKLM
Value：FullInstallVer
选择"Condition1" ，在"属性"对话框中填写如下内容：
Condition：MDACSEARCH>="2.6"
进行这一步是因为在安装.NET框架的时候需要MDAC。

OK，现在编译安装和部署项目，就得到了一个可以同时安装.NET框架的安装程序了