Ramesh Raman's WebLog

Updated IIS 6.0 WMI Provider C# Sample

ramesh_r — Thu, 01 Jul 2004 08:41:00 GMT

Added support for appPools & virtual directories in XMl configuration.

http://blogs.msdn.com/ramesh_r/articles/170665.aspx

IIS 6.0 WMI PROVIDER - SAMPLE

ramesh_r — Thu, 01 Jul 2004 08:31:00 GMT

Modification History:

07/01/04 - added support for vroots & appPools

Sample Described at: http://blogs.msdn.com/ramesh_r/archive/2004/03/24/95109.aspx

//////////////////// sample xml

<?xml version="1.0" encoding="utf-8" ?>
<webSettings>
<serverSettings>
  <appPools>
   <appPool name="My Test App Pool">
    <propertyList>
     <property name="IdleTimeOut" value="20"/>
     <property name="AppPoolQueueLength" value="2000"/>
     <property name="MaxProcesses" value="1"/>
     <property name="PingingEnabled" value="True"/>
     <property name="PingInterval" value="30"/>
     <property name="StartupTimeLimit" value="90"/>
     <property name="ShutdownTimeLimit" value="90"/>
    </propertyList>
   </appPool>
  </appPools>
</serverSettings>
     <webSites>
             <webSite ServerId="1234" ServerComment="My Test WebSite" PathOfDefaultVroot="c:\inetpub\wwwroot\Test" >
                    <siteSettings>
                          <propertyList>
                                 <property name="AllowKeepAlive" value="True"/>
                                 <property name="ConnectionTimeout" value="90"/>
                          </propertyList>
                         <serverBinding Hostname="" IP="" Port="80"/>
                   </siteSettings>
                   <rootSettings>
      <propertyList>
       <property name="AccessRead" value="True"/>
       <property name="AccessScript" value="True"/>
       <property name="AspAllowSessionState" value="False"/>
       <property name="AspScriptTimeOut" value="300"/>
       <property name="AspBufferingOn" value="True"/>
       <property name="EnableDefaultDoc" value="True"/>
       <property name="DefaultDoc" value="Default.aspx"/>
       <property name="AuthPassport" value="True"/>
       <property name="AuthAnonymous" value="True"/>
       <property name="AnonymousPasswordSync" value="True"/>
      </propertyList>
                   </rootSettings>
                   <virtualDirs>
      <virtualDir type="folder" name="vdirA" location="C:\inetpub\wwwroot\Test\vroot1"/>
      <virtualDir type="redirect" name="vdirRedriect" location="http://encarta.msn.com"/>
                   </virtualDirs>
            </webSite>
     </webSites>
</webSettings>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// application /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class App
{
  [STAThread]
  static int Main (string[] args)
  {
   if (args.Length != 2)
   {
    StdOut ("Usage: Xml2IIs <targetServer> <configPath>");
    StdOut (" e.g: Xml2IIs localhost mywebsites.xml");
    return 1;
   }

string target = args[0];
string configPath = args[1];

   XmlConfig config = new XmlConfig (configPath);
   if (config.ApplySettings (target))
    return 0;
   else
    return 1;

}

  public static void LogException (Exception ex)
  {
   Console.Error.WriteLine ("EXCEPTION!> " + ex.Source);
   Console.Error.WriteLine ("EXCEPTION!> " + ex.Message);
   Console.Error.WriteLine ("EXCEPTION!> " + ex.StackTrace);
  }

  public static void StdOut (string msg)
  {
   Console.WriteLine (">{0}", msg);
  }

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// XMLConfig Class ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class XmlConfig
{
  public XmlConfig (string configPath)
  {
   Load (configPath);
  }

  public bool ApplySettings (string target)
  {
   if (_doc == null) return false;

   // connect to WMI on target server
   _wmi = new WmiIIS ();
   _wmi.Connect (target);

if (!_wmi.IsConnected ()) return false;

   // process server settings
   XmlNode serverSettingsNode = _doc.SelectSingleNode (@"webSettings/serverSettings");
   if (serverSettingsNode != null)
   {
    XmlNode appPoolsNode = serverSettingsNode.SelectSingleNode ("appPools");
    foreach (XmlNode appPoolNode in appPoolsNode)
    {
     string name = appPoolNode.Attributes["name"].Value;
     ManagementObject oAppPool = _wmi.CreateAppPool (name);
     if (oAppPool != null)
     {
      // handle properties

      XmlNode propertyNodes = appPoolNode.SelectSingleNode ("propertyList");
      ApplyProperties (oAppPool, propertyNodes);
     }
    }
   }

   // process website nodes
   XmlNodeList siteNodes = _doc.SelectNodes (@"webSettings/webSites/webSite");
   foreach (XmlNode siteNode in siteNodes)
   {
    HandleWebSite (siteNode);
   }

return true;
}

  private bool HandleWebSite (XmlNode siteNode)
  {
   try
   {
    XmlNode settingsNode = siteNode.SelectSingleNode ("siteSettings");

XmlNodeList bindingNodes = settingsNode.SelectNodes ("serverBinding");
ManagementBaseObject[] serverBindings = new ManagementBaseObject[bindingNodes.Count];

    int i = 0;
    foreach (XmlNode bindingNode in bindingNodes)
    {

     serverBindings[i++] =
     _wmi.CreateServerBinding (bindingNode.Attributes["Hostname"].Value,
      bindingNode.Attributes["IP"].Value,
      bindingNode.Attributes["Port"].Value);
    }

    string wmiPath = _wmi.CreateWebSite (siteNode.Attributes["ServerId"].Value,
     siteNode.Attributes["ServerComment"].Value,
     siteNode.Attributes["PathOfDefaultVroot"].Value,
     serverBindings);

ManagementObject oSite = _wmi.GetInstance (wmiPath.Replace ("IIsWebServer", "IIsWebServerSetting"));

App.StdOut ("Connected To..." + oSite.Path);

// handle properties

XmlNode propertyNodes = settingsNode.SelectSingleNode ("propertyList");
ApplyProperties (oSite, propertyNodes);

// settings on the root vdir

    XmlNode rootSettingsNode = siteNode.SelectSingleNode ("rootSettings");
    if (rootSettingsNode != null)
    {
     propertyNodes = rootSettingsNode.SelectSingleNode ("propertyList");

     string objectPath = string.Format ("IIsWebVirtualDirSetting='{0}'", oSite["Name"] + "/ROOT");
     ManagementObject oRoot = _wmi.GetInstance (objectPath);
     ApplyProperties (oRoot, propertyNodes);
    }

// handle vroots

XmlNode virtualDirsNode = siteNode.SelectSingleNode ("virtualDirs");

    foreach (XmlNode virtualDirNode in virtualDirsNode.ChildNodes)
    {
     string type = virtualDirNode.Attributes["type"].Value;
     string name = virtualDirNode.Attributes["name"].Value;
     string location = virtualDirNode.Attributes["location"].Value;

string vdirPath = oSite["Name"] + "/ROOT/" + name;

ManagementObject oVDir = _wmi.CreateVirtualDir (type, vdirPath, location);
}

oSite.Put ();

return true;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

}

  private bool ApplyProperties (ManagementObject o, XmlNode propertyNodes)
  {
   try
   {

if (propertyNodes != null && propertyNodes.ChildNodes.Count > 0)
{

     Hashtable tableProperty = new Hashtable ();
     foreach (XmlNode propertyNode in propertyNodes.ChildNodes)
     {
      string name, value;
      name = propertyNode.Attributes["name"].Value;
      value = propertyNode.Attributes["value"].Value;

tableProperty.Add (name, value);
}

return _wmi.ApplyPropertyList (o, tableProperty);
}

   }
   catch (Exception ex)
   {
    App.LogException (ex);
   }

return false;
}

  private bool Load (string configPath)
  {
   try
   {
    _doc = new XmlDocument ();
    _doc.Load (configPath);

return true;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    _doc = null;
    return false;
   }

}

private XmlDocument _doc = null;
private WmiIIS _wmi = null;
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// WmiIIS Class /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

public class WmiIIS
{
  public WmiIIS ()
  {
  }

  public bool IsConnected()
  {
   if (_target == null || _connection == null || _scope == null) return false;
   return _scope.IsConnected;
  }

  public bool Connect (string target)
  {
   if (target == null) return false;

   try
   {
    _target = target;
    _connection = new ConnectionOptions ();
    _scope = new ManagementScope (@"\\" + target + @"\root\MicrosoftIISV2", _connection);
    _scope.Connect ();

    App.StdOut ("Connected To... " + target);
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

return IsConnected ();
}

  public ManagementObject CreateServerBinding (string HostName, string IP, string Port)
  {
   try
   {
    ManagementClass classBinding = new ManagementClass (_scope, new ManagementPath ("ServerBinding"), null);
    ManagementObject serverBinding = classBinding.CreateInstance ();
    serverBinding.Properties["Hostname"].Value = HostName;
    serverBinding.Properties["IP"].Value = IP;
    serverBinding.Properties["Port"].Value = Port;
    serverBinding.Put ();
    return serverBinding;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return null;
   }
  }

  public string CreateWebSite (string serverID, string serverComment, string defaultVrootPath, ManagementBaseObject[] serverBinding)
  {
   if (serverID == null || serverID.Length == 0) return null;
   if (defaultVrootPath == null || defaultVrootPath.Length == 0) return null;
   if (serverComment == null || serverComment.Length == 0) return null;
   if (serverBinding == null) return null;

try
{

ManagementObject oW3SVC = new ManagementObject (_scope, new ManagementPath (@"IIsWebService='W3SVC'"), null);
App.StdOut("Connected To..." + oW3SVC.Path);

    if (IsWebSiteExists (serverID))
    {
    App.StdOut ("Site Already Exists..." + serverID);
    DeleteSite (serverID);
    }

ManagementBaseObject inputParameters = oW3SVC.GetMethodParameters ("CreateNewSite");

    inputParameters["ServerComment"] = serverComment;
    inputParameters["ServerBindings"] = serverBinding;
    inputParameters["PathOfRootVirtualDir"] = defaultVrootPath;
    inputParameters["ServerId"] = serverID;

    ManagementBaseObject outParameter = null;
    outParameter = oW3SVC.InvokeMethod ("CreateNewSite", inputParameters, null);
    return (string)outParameter.Properties["ReturnValue"].Value;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return null;
   }
  }

  public ManagementObject CreateVirtualDir (string type, string wmiPath, string location)
  {
   try
   {
    ManagementClass classVDir = new ManagementClass (_scope, new ManagementPath ("IIsWebVirtualDirSetting"), null);
    ManagementObject objectVDir = classVDir.CreateInstance ();

type = type.ToLower ();

    if (type == "folder")
    {
     objectVDir.Properties["Name"].Value = wmiPath;
     objectVDir.Properties["Path"].Value = location;
     objectVDir.Put ();
    }
    else if (type == "redirect")
    {
     objectVDir.Properties["Name"].Value = wmiPath;
     objectVDir.Properties["Path"].Value = "REDIRECT";
     objectVDir.Properties["HttpRedirect"].Value = location;
     objectVDir.Put ();
    }
    else
    {
     objectVDir = null;
    }

    if (objectVDir != null)
    {
     App.StdOut ("CREATED VDIR " + objectVDir["Name"]);
    }

return objectVDir;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return null;
   }
  }

  public ManagementObject CreateAppPool (string name)
  {
   try
   {
    ManagementClass classAppPool = new ManagementClass (_scope, new ManagementPath ("IIsApplicationPoolSetting"), null);
    ManagementObject objectAppPool = classAppPool.CreateInstance ();

objectAppPool.Properties["Name"].Value = "W3SVC/AppPools/" + name;
objectAppPool.Put ();

App.StdOut ("CREATED APP POOL: " + objectAppPool["Name"]);

return objectAppPool;

   }
   catch (Exception ex)
   {
    App.LogException(ex);
    return null;
   }

}

  public bool ApplyPropertyList(ManagementObject managementObject, Hashtable tableProperty)
  {
   try
   {
    App.StdOut ("Setting Properties On..." + managementObject.Path);

    foreach (string key in tableProperty.Keys)
    {
    Console.WriteLine ("Setting...{0}={1}", key, tableProperty[key]);
    managementObject.Properties[key].Value = tableProperty[key];
    }

    managementObject.Put ();
    return true;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }
  }

  public ManagementObject GetInstance (string wmiPath)
  {
   try
   {
    return new ManagementObject(_scope, new ManagementPath(wmiPath),null);
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return null;
   }
  }

  public bool IsWebSiteExists (string serverID)
  {
   try
   {
    string siteName = "W3SVC/" + serverID;
    ManagementObjectSearcher searcher = new ManagementObjectSearcher (_scope, new ObjectQuery ("SELECT * FROM IIsWebServer"), null);

    ManagementObjectCollection webSites = searcher.Get ();
    foreach (ManagementObject webSite in webSites)
    {
    if ((string)webSite.Properties["Name"].Value == siteName)
    return true;
    }

    return false;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }
  }

  public bool DeleteSite (string serverID)
  {
   try
   {
    string serverName = "W3SVC/" + serverID;
    ManagementObject webSite = new ManagementObject (_scope, new ManagementPath (@"IIsWebServer='" + serverName + "'"), null);

App.StdOut ("Stopping..." + webSite.Path);
webSite.InvokeMethod ("Stop", null);

App.StdOut ("Deleting..." + webSite.Path);
webSite.Delete();

webSite = null;

    return true;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }
  }

string _target = null;
ManagementScope _scope = null;
ConnectionOptions _connection = null;

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Enumerating FXCop Rules

ramesh_r — Fri, 26 Mar 2004 07:44:00 GMT

Here's some code to enumerate FXCop rules , the input is a path to a folder containing assemblies that implement the rules, the output is an XML file that lists all the rules by assembly. I needed the list to import into a db.

The function loads an assembly and searches for classes that implement the interface IRule (defined in the FXCop SDK), it then queries the interface for the rule Name & Description, the type name of the class that implements the rule is also descriptive of what the rule does, it's included in the XML output too.

using System;
using System.Reflection;
using System.IO;
using System.Xml;
using Microsoft.Tools.FxCop.Sdk;

namespace FXCopRuleEnumerator
{
class App
{

  [STAThread]
  static void Main(string[] args)
  {
   if (args.Length != 1) return;

string assemblyFolder = args[0];

   XmlDocument doc = new XmlDocument();
   XmlNode rootNode = doc.CreateNode(XmlNodeType.Element,"rules",null);
   doc.AppendChild(rootNode);

   foreach (string assemblyPath in Directory.GetFiles(assemblyFolder))
   {
    EnumerateRules(assemblyPath,doc);
   }

   Console.WriteLine(doc.OuterXml);
  }

  static void EnumerateRules(string assemblyPath,XmlDocument doc)
  {
   Assembly assembly = Assembly.LoadFrom(assemblyPath);

XmlNode assemblyNode = doc.CreateNode(XmlNodeType.Element,"assembly",null);
doc.DocumentElement.AppendChild(assemblyNode);

int countRules = 0;

   foreach (Module module in assembly.GetModules())
   {
    foreach (Type type in module.GetTypes())
    {
     if (type.IsClass && !type.IsAbstract)
     {

      ConstructorInfo ctor = type.GetConstructor(Type.EmptyTypes);
      if (ctor != null)
      {
       object o = ctor.Invoke(null);
       IRule aRule = o as IRule;
       if (aRule != null)
       {
        countRules++;

XmlNode ruleNode = doc.CreateNode(XmlNodeType.Element,"rule",null);
assemblyNode.AppendChild(ruleNode);

        XmlNode childNode = doc.CreateNode(XmlNodeType.Element,"Type",null);
        childNode.InnerText = type.Name;
        ruleNode.AppendChild(childNode);

        childNode = doc.CreateNode(XmlNodeType.Element,"Name",null);
        childNode.InnerText = aRule.Name;
        ruleNode.AppendChild(childNode);

        childNode = doc.CreateNode(XmlNodeType.Element,"Description",null);
        childNode.InnerText = aRule.Description;
        ruleNode.AppendChild(childNode);
       }

}
}

   XmlAttribute attribute = doc.CreateAttribute("","name","");
   attribute.Value = assembly.FullName;
   assemblyNode.Attributes.Append(attribute);

   attribute = doc.CreateAttribute("","count","");
   attribute.Value = countRules.ToString();
   assemblyNode.Attributes.Append(attribute);
  }
}

}

How do you manage your FXCop Rules?

ramesh_r — Thu, 25 Mar 2004 09:30:00 GMT

For those of you who use FXCop

Do you apply all rules, or do you use a subset that applies to your specific situation?
If you're specific about your rules, what process do use to select them (e.g. does someone do the groundwork and then you meet as a team to decide on the final list; how do you keep the list upto date) ?

We run FXCop as part of our build and are in the process of 'deciding' which rules we'd like to apply (to begin with). The FXCop project file is in XML and i'm thinking on the lines of creating it dynamically so that it uses the 'current' set of applicable rules (or) apply all rules and filter the output using the applicable rules (and then have the build take the appropriate action - fail, log a bug...).

Apart from the rules themselves, i think it's important to also keep information on why certain rules apply and others don't (e.g. project uses it's own variable naming convention). You could just store this information in a doc, but then you'd need to keep FXCop project file in sync with the doc. Importing all rules into a db and tagging applicable ones and yes/no information, would make it easier to generate the FXCop project (i.e. the rules section) ; a web front-end could be a focal point for a team discussion on which rules apply - or is this overkill?

Using the WMI Provider to Configure IIS 6.0 - A Data Driven Approach

ramesh_r — Wed, 24 Mar 2004 08:04:00 GMT

Many of us use scripts to setup our web servers, a lot of the work is boilerplate - create sites, vroots.... To ease maintanence work over the last year i've moved to a data driven approach to setting up web sites. I use an XML configuration file to describe the web site and a driver program that uses WMI to configure IIS based on the XML. Some of the benefits of this are : you only need to make fixes to the single driver program ; anyone can edit/create the configuration XML; operations has to deal with a single way to setup all your sites; updates to the schema are available to all sites (e.g: you add support to set content expiration). I spent some time today looking at support for WMI in C# and thought it may be useful to folks who're just starting out. In the rest of this post i'll show you a simplified example to give you a better feel for what i'm talking about.

You can find the WMI IIS 6.0 provider described here.

The Scripting Guys have a great introduction to WMI.

You can find some WMI related tools on MSDN.

Sample Configuration:

<?xml version="1.0" encoding="utf-8" ?>
<webSettings>
     <webSites>
             <webSite ServerId="1234" ServerComment="My Test WebSite" PathOfDefaultVroot="c:\inetpub\wwwroot\Test" >
                    <siteSettings>
                          <propertyList>
                                 <property name="AllowKeepAlive" value="True"/>
                                 <property name="ConnectionTimeout" value="90"/>
                          </propertyList>
                         <serverBinding Hostname="" IP="" Port="80"/>
                   </siteSettings>
            </webSite>
     </webSites>
</webSettings>

The property names used in the configuration match the names used by WMI, to make it easier to relate to the documentation. I've left out a lot in the sample such as ... templates to store common settings (e.g. custom error pages, supported mime types, log settings); server settings (e.g. AppPool creation); vroot creation ...

The driver program (a console app) uses a helper class to load and apply the configuration to the target server. The WMI classes are in the System.Management namespace (that you need to add a reference to). This is just a first stab at using the WMI classes, do let me know if i'm missing something.

class App
{
  [STAThread]
  static int Main (string[] args)
  {

   if (args.Length != 2)
   {
    StdOut ("Usage: Xml2IIs <targetServer> <configPath>");
    StdOut (" e.g: Xml2IIs localhost mywebsites.xml");
    return 1;
   }

string target = args[0];
string configPath = args[1];

   XmlConfig config = new XmlConfig (configPath);
   if (config.ApplySettings (target))
    return 0;
   else
    return 1;
  }

  public static void StdOut (string msg)
  {
   Console.WriteLine (">{0}", msg);
  }

}

XmlConfig is the helper class that processes the XML configuration, it moves thru' the different sections and uses a WMI wrapper class to apply the settings to the IIS Metabase

public class XmlConfig
{
  public XmlConfig (string configPath)
  {
   Load (configPath);
  }

  public bool ApplySettings (string target)
  {
   if (_doc == null) return false;

   // connect to WMI on target server
   _wmi = new WmiIIS ();
   _wmi.Connect (target);

if (!_wmi.IsConnected ()) return false;

   // process website nodes
   XmlNodeList siteNodes = _doc.SelectNodes (@"webSettings/webSites/webSite");
   foreach (XmlNode siteNode in siteNodes)
   {
    HandleWebSite (siteNode);
   }

return true;
}

  private bool HandleWebSite (XmlNode siteNode)
  {
   try
   {
    XmlNode settingsNode = siteNode.SelectSingleNode ("siteSettings");

XmlNodeList bindingNodes = settingsNode.SelectNodes ("serverBinding");
ManagementBaseObject[] serverBindings = new ManagementBaseObject[bindingNodes.Count];

    int i = 0;
    foreach (XmlNode bindingNode in bindingNodes)
    {

     serverBindings[i++] =
     _wmi.CreateServerBinding (bindingNode.Attributes["Hostname"].Value,
      bindingNode.Attributes["IP"].Value,
      bindingNode.Attributes["Port"].Value);
    }

ManagementObject oSite = _wmi.GetInstance (wmiPath.Replace("IIsWebServer","IIsWebServerSetting"));

App.StdOut("Connected To..." + oSite.Path);

XmlNode propertyNodes = settingsNode.SelectSingleNode ("propertyList");

if (propertyNodes != null && propertyNodes.ChildNodes.Count > 0)
{

tableProperty.Add (name, value);
}

_wmi.ApplyPropertyList (oSite, tableProperty);
}

return true;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

}

  private bool Load (string configPath)
  {
   try
   {
    _doc = new XmlDocument ();
    _doc.Load (configPath);

return true;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    _doc = null;
    return false;
   }

}

private XmlDocument _doc = null;
private WmiIIS _wmi = null;
}

Finally we have a WMI wrapper class that interfaces with WMI to actually update the IIS metabase

public class WmiIIS
{
  public WmiIIS ()
  {
  }

  public bool IsConnected()
  {
   if (_target == null || _connection == null || _scope == null) return false;
   return _scope.IsConnected;
  }

  public bool Connect (string target)
  {
   if (target == null) return false;

   try
   {
    _target = target;
    _connection = new ConnectionOptions ();
    _scope = new ManagementScope (@"\\" + target + @"\root\MicrosoftIISV2", _connection);
    _scope.Connect ();

    App.StdOut ("Connected To... " + target);
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

return IsConnected ();
}

}

try
{

ManagementObject oW3SVC = new ManagementObject (_scope, new ManagementPath (@"IIsWebService='W3SVC'"), null);
App.StdOut("Connected To..." + oW3SVC.Path);

    if (IsWebSiteExists (serverID))
    {
     App.StdOut ("Site Already Exists..." + serverID);
     DeleteSite (serverID);
    }

ManagementBaseObject inputParameters = oW3SVC.GetMethodParameters ("CreateNewSite");

    ManagementBaseObject outParameter = null;
    outParameter = oW3SVC.InvokeMethod ("CreateNewSite", inputParameters, null);
    return (string)outParameter.Properties["ReturnValue"].Value;

   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return null;
   }

}

  public bool ApplyPropertyList(ManagementObject managementObject, Hashtable tableProperty)
  {
   try
   {
    App.StdOut ("Setting Properties On..." + managementObject.Path);

    foreach (string key in tableProperty.Keys)
    {
     Console.WriteLine ("Setting...{0}={1}", key, tableProperty[key]);
     managementObject.Properties[key].Value = tableProperty[key];
    }

    managementObject.Put ();
    return true;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

}

    ManagementObjectCollection webSites = searcher.Get ();
    foreach (ManagementObject webSite in webSites)
    {
     if ((string)webSite.Properties["Name"].Value == siteName)
      return true;
    }

    return false;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

}

App.StdOut ("Stopping..." + webSite.Path);
webSite.InvokeMethod ("Stop", null);

App.StdOut ("Deleting..." + webSite.Path);
webSite.Delete();

webSite = null;

    return true;
   }
   catch (Exception ex)
   {
    App.LogException (ex);
    return false;
   }

}

  string _target = null;
  ManagementScope _scope = null;
  ConnectionOptions _connection = null;
}

Bye for now

- ramesh

Ramesh Signing On

ramesh_r — Tue, 23 Mar 2004 07:21:00 GMT

Hi,

Welcome to my blog.

I've been reading other's blogs for a while now and finding it really useful, and would like to make a contribution of my own. I don't have specific theme for my blog , except to share what i think may be useful to a wider audience. On a technical level my interests are in .Net Web Services, web performance, site operations/management. I work on encarta.msn.com.