使用ADSI实现IIS管理,WEB站点管理系统核心代码

using System; 
using System.Collections.Generic; 
using System.Text; 
using System.IO; 
using System.Collections; 
using System.DirectoryServices; 
using IISMModel; 
using System.Configuration; 
using System.Web; 
 
namespace IISMBLL 
{ 
    /// <summary> 
    /// IIS站点管理器 
    /// </summary> 
    public class IISManager 
    { 
        const string W3SVC_PATH = "IIS://localhost/W3SVC"; 
        // Access Flags 
        const int MD_ACCESS_READ = 0x00000001; //Allow read access. 
        const int MD_ACCESS_SCRIPT = 0x00000200; // Allow script execution. 
 
        /// <summary> 
        /// 验证某个虚拟目录是否存在 
        /// </summary> 
        /// <param name="baseSiteName">虚拟目录所在的基础站点</param> 
        /// <param name="virtualDirName">虚拟目录名</param> 
        /// <returns>存在返回真,否则返回假</returns> 
        public Boolean ValidateVirWebSite(string baseSiteName,string virtualDirName) 
        { 
            if (string.IsNullOrEmpty(baseSiteName)) 
            { 
                throw new Exception(IISModel_MSG.IISBLL_IISM_ERROR_VIRDIR_SITE_EMPTY); 
            } 
 
            if (string.IsNullOrEmpty(virtualDirName)) 
            { 
                throw new Exception(IISModel_MSG.IISBLL_IISM_ERROR_VIRDIR); 
            } 
 
            // 站点ID 
            int _WebSiteID = 1; 
            _WebSiteID = GetSiteID(baseSiteName, "localhost"); 
            if (_WebSiteID == 0) 
            { 
                throw new Exception(IISModel_MSG.IISBLL_IISM_ERROR_VIRDIR_SITE_NOTFOUND); 
            } 
 
            String siteRoot = "IIS://localhost/W3SVC/" + _WebSiteID.ToString() + "/ROOT"; 
            DirectoryEntry root = new DirectoryEntry(siteRoot); 
            foreach (DirectoryEntry child in root.Children) 
            { 
                if (child.Name.ToLower() == virtualDirName) 
                { 
                    return true; 
                } 
            } 
            return false; 
        } 
 
        /// <summary> 
        /// 验证某个站点是否存在 
        /// </summary> 
        /// <param name="siteName"></param> 
        /// <returns></returns> 
        public Boolean ValidateWebSite(string siteName) 
        { 
            return 
                GetSiteID(siteName, "localhost")>0; 
        } 
 
        /// <summary> 
        /// 在主机上创建虚拟目录 
        /// </summary> 
        public void CreateVirWebSite(string _virtualDirName, string _physicalPath) 
        { 
            try 
            { 
                // 站点ID 
                int _WebSiteID = 1; 
                //得到默认站点 
                _WebSiteID = GetSiteID(ConfigurationManager.AppSettings["defaultSite"], "localhost"); 
                if (_WebSiteID == 0) 
                { 
                    _WebSiteID = 1; 
                } 
                if (string.IsNullOrEmpty(_virtualDirName)) 
                { 
                    throw new NullReferenceException("创建虚拟目录名不能为空"); 
                } 
 
                String constIISWebSiteRoot = "IIS://localhost/W3SVC/" + _WebSiteID.ToString() + "/ROOT"; 
                string virtualDirName = _virtualDirName; //虚拟目录名称:Monitor 
                string physicalPath = _physicalPath; //虚拟目录物理路径 
 
                if (String.IsNullOrEmpty(physicalPath)) 
                { 
                    throw new NullReferenceException("创建虚拟目录的物理路径不能为空"); 
                } 
 
                DirectoryEntry root = new DirectoryEntry(constIISWebSiteRoot); 
 
                // 如果虚拟目录存在则删除 
                foreach (System.DirectoryServices.DirectoryEntry v in root.Children) 
                { 
 
                    if (v.Name == _virtualDirName) 
                    { 
                        // Delete the specified virtual directory if it already exists 
                        try 
                        { 
                            root.Invoke("Delete", new string[] { v.SchemaClassName, _virtualDirName }); 
                            root.CommitChanges(); 
                        } 
                        catch 
                        { 
                            throw;                             
                        } 
                    } 
                } 
 
                DirectoryEntry tbEntry = root.Children.Add(virtualDirName, "IIsWebVirtualDir"); 
                 
                tbEntry.Properties["Path"][0] = physicalPath;  //虚拟目录物理路径 
                tbEntry.Invoke("AppCreate", true); 
                tbEntry.Properties["AccessRead"][0] = true;   //设置读取权限 
                tbEntry.Properties["ContentIndexed"][0] = true; 
                tbEntry.Properties["DefaultDoc"][0] = "index.aspx,Default.aspx"; //设置默认文档,多值情况下中间用逗号分割 
                tbEntry.Properties["AppFriendlyName"][0] = virtualDirName; //虚拟目录名称:Monitor 
                tbEntry.Properties["AccessScript"][0] = true; //执行权限 
                tbEntry.Properties["AppIsolated"][0] = "1"; 
                tbEntry.Properties["DontLog"][0] = true;  // 是否记录日志                 
                tbEntry.Properties["AuthFlags"][0] = 1;// 设置目录的安全性，0表示不允许匿名访问，1为允许，3为基本身份验证，7为windows继承身份验证 
                tbEntry.CommitChanges(); 
 
                // 增加MIME 的类型：flv 
                //SetMimeTypeProperty(constIISWebSiteRoot, ".flv", "flv"); 
 
                // 修改IIS属性 
                //SetSingleProperty("IIS://localhost/W3SVC/" + _WebSiteID.ToString(), "ServerBindings", ":8080:"); 
 
                ////得到现默认站点的IP 端口 描述        
                //string strServerBindings = root.Properties["ServerBindings"].Value.ToString(); 
                ////解出端口Port 
                //string[] strArr = strServerBindings.Split(':'); 
                ////重新赋值为8080 
                //root.Properties["ServerBindings"].Value = strArr[0] + ":8080:" + strArr[2]; 
 
                root.CommitChanges();//确认更改 
 
            } 
            catch 
            { 
                 
            } 
        } 
 
        /// <summary> 
        /// 删除Web虚拟目录 
        /// </summary> 
        /// <param name="_virtualDirName"></param> 
        public void RemoveVirWebSite(string _virtualDirName) 
        { 
            // 站点ID 
            int _WebSiteID = 1; 
            //得到默认站点 
            _WebSiteID = GetSiteID(ConfigurationManager.AppSettings["defaultSite"], "localhost"); 
            if (_WebSiteID == 0) 
            { 
                _WebSiteID = 1; 
            } 
            if (string.IsNullOrEmpty(_virtualDirName)) 
            { 
                throw new NullReferenceException("创建虚拟目录名不能为空"); 
            } 
 
            String constIISWebSiteRoot = "IIS://localhost/W3SVC/" + _WebSiteID.ToString() + "/ROOT"; 
            string virtualDirName = _virtualDirName; //虚拟目录名称:Monitor 
 
            using (DirectoryEntry root = new DirectoryEntry(constIISWebSiteRoot)) 
            { 
                // 如果虚拟目录存在则删除 
                foreach (System.DirectoryServices.DirectoryEntry v in root.Children) 
                { 
                    if (v.Name == _virtualDirName) 
                    { 
                        root.Invoke("Delete", new string[] { v.SchemaClassName, _virtualDirName }); 
                        root.CommitChanges(); 
                        break; 
                    } 
                } 
                root.Close();  
            } 
        } 
 
        /// <summary> 
        /// 创建独立的Web站点 
        /// </summary> 
        /// <param name="siteName"></param> 
        /// <param name="realPath"></param> 
        public void CreateWebSite(string siteName, string realPath) 
        { 
            if (string.IsNullOrEmpty(siteName)) 
            { 
                throw new NullReferenceException("创建站点的站点名字不能为空"); 
            } 
            if (string.IsNullOrEmpty(realPath)) 
            { 
                throw new NullReferenceException("创建站点的站点真是路径不能为空"); 
            } 
 
            DirectoryEntry root = new DirectoryEntry(W3SVC_PATH); 
 
            //判断站点是否已经存在,如果存在,则删除已有站点 
            int siteID = GetSiteID(siteName, "localhost"); 
            if (siteID > 0) 
            { 
                throw new Exception("要创建的站点已经存在"); 
            } 
 
            siteID = getNewWebSiteID(); 
            DirectoryEntry currentWeb = 
                root.Children.Add(siteID.ToString(), "IIsWebServer"); 
            currentWeb.CommitChanges(); 
 
            //currentWeb.Properties["Location"].Value = "/LM/W3SVC/" + siteID.ToString(); 
            currentWeb.Properties["AuthFlags"][0] = "0"; 
            currentWeb.Properties["MaxBandwidth"][0] = "1048576"; 
            currentWeb.Properties["MaxConnections"][0] = "10"; 
            currentWeb.Properties["ServerAutoStart"][0] = "true"; 
            currentWeb.Properties["ServerBindings"].Value = ":80:" + siteName; 
            currentWeb.Properties["ServerComment"][0] = siteName; 
             
            // 添加web虚拟目录 
            DirectoryEntry virEntry = currentWeb.Children.Add("root","IIsWebVirtualDir"); 
            virEntry.CommitChanges(); 
            //virEntry.Properties["Location"].Value = "/LM/W3SVC/"+siteID.ToString()+"/root"; 
            virEntry.Properties["AccessFlags"][0] = MD_ACCESS_READ | MD_ACCESS_SCRIPT; 
            virEntry.Properties["AppFriendlyName"][0] = siteName; 
            virEntry.Properties["AppIsolated"][0] = "2"; 
            virEntry.Properties["AppRoot"][0] = "/LM/W3SVC/" + siteID.ToString() + "/Root"; 
            virEntry.Properties["AuthFlags"][0] = 1 | 7;// 设置目录的安全性，0表示不允许匿名访问，1为允许，3为基本身份验证，7为windows继承身份验证             
            virEntry.Properties["Path"][0] = realPath;  //虚拟目录物理路径 
             
            virEntry.CommitChanges(); 
            currentWeb.CommitChanges(); 
 
            virEntry.Close(); 
            currentWeb.Close(); 
            root.Close(); 
        } 
 
        /// <summary> 
        /// 删除Web站点 
        /// </summary> 
        /// <param name="siteName"></param> 
        public void RemoveWebSite(string siteName) 
        { 
            if (string.IsNullOrEmpty(siteName)) 
            { 
                throw new NullReferenceException("创建站点的站点名字不能为空"); 
            } 
 
            using (DirectoryEntry root = new DirectoryEntry(W3SVC_PATH)) 
            { 
                foreach (DirectoryEntry Child in root.Children) 
                { 
                    if (Child.SchemaClassName == "IIsWebServer") 
                    { 
                        string WName = Child.Properties["ServerComment"][0].ToString(); 
                        if (siteName.ToLower() == WName.ToLower()) 
                        { 
                            Child.DeleteTree(); 
                            root.CommitChanges(); 
                            break; 
                        }   
                    } 
                                       
                } 
                root.Close(); 
            } 
 
             
        } 
 
        /// <summary> 
        /// 得到新的站点ID 
        /// </summary> 
        /// <returns></returns> 
        private int getNewWebSiteID() 
        { 
           using(System.DirectoryServices.DirectoryEntry rootEntry =  
               new System.DirectoryServices.DirectoryEntry(W3SVC_PATH)) 
           { 
               int siteID = 1; 
               //得到现有的站点标识 
               foreach (System.DirectoryServices.DirectoryEntry entry in rootEntry.Children) 
               { 
                   if (entry.SchemaClassName == "IIsWebServer") 
                   { 
                       int ID = Convert.ToInt32(entry.Name); 
 
                       if (ID >= siteID) 
                       { 
                           siteID = ID + 1; 
                       } 
                   } 
               } 
               rootEntry.Close(); 
               return siteID; 
           } 
        } 
 
        #region 根据站点名称获取站点ID(标识) 
 
        /// <summary> 
        /// 根据站点名称获取站点ID(标识) 
        /// </summary> 
        /// <param name="webSiteName">站点名称</param> 
        /// <param name="serverIP">主机IP</param> 
        /// <returns>站点ID</returns> 
        private int GetSiteID(string webSiteName, string serverIP) 
        { 
            int SiteID = 0; 
            try 
            { 
                DirectoryEntry root = new DirectoryEntry(@"IIS://" + serverIP + "/W3SVC");                 
                foreach (DirectoryEntry Child in root.Children) 
                {                     
                    string WName = Child.Properties["ServerComment"][0].ToString(); 
                    if (webSiteName == WName) 
                    {                         
                        SiteID = Convert.ToInt32(Child.Name); 
                        return SiteID; 
                    } 
                    WName = ""; 
                } 
            } 
            catch 
            { 
                SiteID = 0; 
            } 
            return SiteID; 
        } 
 
        #endregion 
 
        /// <summary> 
        /// 设置IIS的MIME类型，SetMimeTypeProperty("IIS://localhost/W3SVC/1/Root", ".hlp", "application/winhlp"); 
        /// </summary> 
        /// <param name="metabasePath"></param> 
        /// <param name="newExtension"></param> 
        /// <param name="newMimeType"></param> 
        static void SetMimeTypeProperty(string metabasePath, string newExtension, string newMimeType) 
        { 
            //  metabasePath is of the form "IIS://<servername>/<path>" 
            //    for example "IIS://localhost/W3SVC/1/Root"  
            //  newExtension is of the form ".<extension>", for example, ".hlp" 
            //  newMimeType is of the form "<application>", for example, "application/winhlp" 
            Console.WriteLine("\nAdding {1}->{2} to the MimeMap property at {0}:", metabasePath, newExtension, newMimeType); 
 
            try 
            { 
                DirectoryEntry path = new DirectoryEntry(metabasePath); 
                PropertyValueCollection propValues = path.Properties["MimeMap"]; 
                Console.WriteLine(" Old value of MimeMap has {0} elements", propValues.Count); 
 
                object exists = null; 
                foreach (object value in propValues) 
                { 
                    // IISOle requires a reference to the Active DS IIS Namespace Provider in Visual Studio .NET 
                    IISOle.IISMimeType mimetypeObj = (IISOle.IISMimeType)value; 
                    Console.WriteLine("  {0}->{1}", mimetypeObj.Extension, mimetypeObj.MimeType); 
                    if (newExtension == mimetypeObj.Extension) 
                        exists = value; 
                } 
 
                if (null != exists) 
                { 
                    propValues.Remove(exists); 
                    Console.WriteLine(" Found an entry for {0}; removing it before adding the new one.", newExtension); 
                } 
 
                IISOle.MimeMapClass newObj = new IISOle.MimeMapClass(); 
                newObj.Extension = newExtension; 
                newObj.MimeType = newMimeType; 
                propValues.Add(newObj); 
                path.CommitChanges(); 
                Console.WriteLine(" Done."); 
 
            } 
            catch (Exception ex) 
            { 
                if ("HRESULT 0x80005006" == ex.Message) 
                    Console.WriteLine(" Property MimeMap does not exist at {0}", metabasePath); 
                else 
                    Console.WriteLine("Failed in SetMimeTypeProperty with the following exception: \n{0}", ex.Message); 
            } 
        } 
 
        /// <summary> 
        /// 修改IIS属性 
        /// </summary> 
        /// <param name="metabasePath"></param> 
        /// <param name="propertyName"></param> 
        /// <param name="newValue"></param> 
        static void SetSingleProperty(string metabasePath, string propertyName, object newValue) 
        { 
            //  metabasePath is of the form "IIS://<servername>/<path>" 
            //    for example "IIS://localhost/W3SVC/1"  
            //  propertyName is of the form "<propertyName>", for example "ServerBindings" 
            //  value is of the form "<intStringOrBool>", for example, ":80:" 
            Console.WriteLine("\nSetting single property at {0}/{1} to {2} ({3}):", 
                metabasePath, propertyName, newValue, newValue.GetType().ToString()); 
 
            try 
            { 
                DirectoryEntry path = new DirectoryEntry(metabasePath); 
                PropertyValueCollection propValues = path.Properties[propertyName]; 
                string oldType = propValues.Value.GetType().ToString(); 
                string newType = newValue.GetType().ToString(); 
                Console.WriteLine(" Old value of {0} is {1} ({2})", propertyName, propValues.Value, oldType); 
                if (newType == oldType) 
                { 
                    path.Properties[propertyName][0] = newValue; 
                    path.CommitChanges(); 
                    Console.WriteLine("Done"); 
                } 
                else 
                    Console.WriteLine(" Failed in SetSingleProperty; type of new value does not match property"); 
            } 
            catch (Exception ex) 
            { 
                if ("HRESULT 0x80005006" == ex.Message) 
                    Console.WriteLine(" Property {0} does not exist at {1}", propertyName, metabasePath); 
                else 
                    Console.WriteLine("Failed in SetSingleProperty with the following exception: \n{0}", ex.Message); 
            } 
        } 
         
        /// <summary> 
        /// 创建FTP虚拟目录 
        /// </summary> 
        /// <param name="virDirName"></param> 
        /// <param name="realPath"></param> 
        public void CreateFTPVirDir(string virDirName,string realPath) 
        { 
              string   strSchema=   "IIsFtpVirtualDir";    
              string   strRootSubPath   =   "/MSFTPSVC/1/Root"; 
 
              string FtpName = virDirName; 
              string DirName = realPath;    
                 
              DirectoryEntry   deRoot=   new   DirectoryEntry("IIS://localhost"+   strRootSubPath); 
 
              try 
              { 
                  deRoot.RefreshCache();    
                  DirectoryEntry   deNewVDir   =   deRoot.Children.Add(FtpName,strSchema);    
                     
                  //deNewVDir.Properties["Path"].Insert(0,DirName); 
                  deNewVDir.Properties["Path"][0] = DirName; 
                  deNewVDir.Properties["AccessRead"][0] = true; 
                  deNewVDir.Properties["AccessWrite"][0] = true; 
        
                  deNewVDir.CommitChanges();    
                  deRoot.CommitChanges();                    
                  deNewVDir.Close();    
                  deRoot.Close();    
              } 
              catch (Exception) 
              { 
                   
                  throw; 
              } 
        } 
 
        /// <summary> 
        /// 删除FTP虚拟目录 
        /// </summary> 
        /// <param name="virDirName"></param> 
        public void RemoveFTPVirDir(string virDirName) 
        { 
            string strSchema = "IIsFtpVirtualDir"; 
            string strRootSubPath = "/MSFTPSVC/1/Root"; 
            string FtpName = virDirName; 
 
            using (DirectoryEntry root = new DirectoryEntry("IIS://localhost" + strRootSubPath)) 
            { 
                root.RefreshCache(); 
                //如果虚拟目录存在则删除 
                foreach (DirectoryEntry item in root.Children) 
                {                     
                    if (item.Name == virDirName) 
                    { 
                        root.Invoke("Delete", new string[] { strSchema, virDirName }); 
                        root.CommitChanges(); 
                        break; 
                    } 
                } 
                root.Close(); 
            } 
        } 
 
        public string GetBaseUrl(HttpContext context) 
        { 
            return 
                context.Request.Url.Scheme + "://" + 
                context.Request.Url.Authority +  
                context.Request.ApplicationPath; 
        } 
    } 
 
}