Adding NDoc style comments to the DSL classes

Source/StructureMap/Configuration/DSL/ChildInstanceExpression.cs

@@ -4,6 +4,10 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Part of the Fluent Interface, represents a nonprimitive argument to a 
+    /// constructure function
+    /// </summary>
     public class ChildInstanceExpression : IExpression
     {
         private readonly InstanceExpression _instance;
@@ -28,7 +32,11 @@ public ChildInstanceExpression(InstanceExpression instance, MemoryInstanceMement
             _childType = childType;
         }
 
-
+        /// <summary>
+        /// Use a previously configured and named instance for the child
+        /// </summary>
+        /// <param name="instanceKey"></param>
+        /// <returns></returns>
         public InstanceExpression IsNamedInstance(string instanceKey)
         {
             MemoryInstanceMemento child = MemoryInstanceMemento.CreateReferencedInstanceMemento(instanceKey);
@@ -37,6 +45,11 @@ public InstanceExpression IsNamedInstance(string instanceKey)
             return _instance;
         }
 
+        /// <summary>
+        /// Start the definition of a child instance by defining the concrete type
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
         public InstanceExpression IsConcreteType<T>()
         {
             Type pluggedType = typeof (T);
@@ -78,6 +91,12 @@ internal Type ChildType
             set { _childType = value; }
         }
 
+        /// <summary>
+        /// Registers a configured instance to use as the argument to the parent's
+        /// constructor
+        /// </summary>
+        /// <param name="child"></param>
+        /// <returns></returns>
         public InstanceExpression Is(InstanceExpression child)
         {
             if (child.PluggedType != null && _childType != null)

Source/StructureMap/Configuration/DSL/CreatePluginFamilyExpression.cs

@@ -8,6 +8,9 @@ namespace StructureMap.Configuration.DSL
 {
     public delegate void AlterPluginFamilyDelegate(PluginFamily family);
 
+    /// <summary>
+    /// Represents the parameters for creating instances of a given Type
+    /// </summary>
     public class CreatePluginFamilyExpression : IExpression
     {
         private Type _pluginType;
@@ -42,6 +45,11 @@ void IExpression.Configure(PluginGraph graph)
             graph.Assemblies.Add(assembly);
         }
 
+        /// <summary>
+        /// Sets the default instance of a Type to the definition represented by builder
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <returns></returns>
         public CreatePluginFamilyExpression TheDefaultIs(IMementoBuilder builder)
         {
             builder.ValidatePluggability(_pluginType);
@@ -57,6 +65,13 @@ public CreatePluginFamilyExpression TheDefaultIs(IMementoBuilder builder)
             return this;
         }
 
+        /// <summary>
+        /// Convenience method that sets the default concrete type of the PluginType.  Type T
+        /// can only accept types that do not have any primitive constructor arguments.
+        /// StructureMap has to know how to construct all of the constructor argument types.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
         public CreatePluginFamilyExpression TheDefaultIsConcreteType<T>()
         {
             ExpressionValidator.ValidatePluggabilityOf(typeof (T)).IntoPluginType(_pluginType);
@@ -70,6 +85,12 @@ public CreatePluginFamilyExpression TheDefaultIsConcreteType<T>()
             return this;
         }
 
+        /// <summary>
+        /// Sets the object creation of the instances of the PluginType.  For example:  PerRequest,
+        /// Singleton, ThreadLocal, HttpContext, or Hybrid
+        /// </summary>
+        /// <param name="scope"></param>
+        /// <returns></returns>
         public CreatePluginFamilyExpression CacheBy(InstanceScope scope)
         {
             _alterations.Add(delegate(PluginFamily family)
@@ -81,6 +102,10 @@ public CreatePluginFamilyExpression CacheBy(InstanceScope scope)
             return this;
         }
 
+        /// <summary>
+        /// Convenience method to mark a PluginFamily as a Singleton
+        /// </summary>
+        /// <returns></returns>
         public CreatePluginFamilyExpression AsSingletons()
         {
             _alterations.Add(

Source/StructureMap/Configuration/DSL/InstanceDefaultExpression.cs

@@ -3,6 +3,9 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Use to express the instance of a PluginType for the containing Profile
+    /// </summary>
     public class InstanceDefaultExpression
     {
         private readonly Type _pluginType;
@@ -16,6 +19,11 @@ public InstanceDefaultExpression(Type pluginType, ProfileExpression parent)
             _parent = parent;
         }
 
+        /// <summary>
+        /// Use a named, preconfigured instance as the default instance for this profile 
+        /// </summary>
+        /// <param name="instanceKey"></param>
+        /// <returns></returns>
         public ProfileExpression UseNamedInstance(string instanceKey)
         {
             _instanceKey = instanceKey;
@@ -46,6 +54,11 @@ internal void Configure(Profile profile, PluginGraph graph)
             }
         }
 
+        /// <summary>
+        /// Define the default instance of the PluginType for the containing Profile
+        /// </summary>
+        /// <param name="mementoBuilder"></param>
+        /// <returns></returns>
         public ProfileExpression Use(IMementoBuilder mementoBuilder)
         {
             _mementoBuilder = mementoBuilder;

Source/StructureMap/Configuration/DSL/InstanceExpression.cs

@@ -3,6 +3,9 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Used to define an Instance in code
+    /// </summary>
     public class InstanceExpression : MementoBuilder<InstanceExpression>
     {
         private Type _pluggedType;
@@ -53,12 +56,24 @@ protected override void validate()
         }
 
 
+        /// <summary>
+        /// Start the definition of a primitive argument to a constructor argument
+        /// </summary>
+        /// <param name="propertyName"></param>
+        /// <returns></returns>
         public PropertyExpression WithProperty(string propertyName)
         {
             return new PropertyExpression(this, _memento, propertyName);
         }
 
-
+        /// <summary>
+        /// Starts the definition of a child instance specifying the argument name
+        /// in the case of a constructor function that consumes more than one argument
+        /// of type T
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="propertyName"></param>
+        /// <returns></returns>
         public ChildInstanceExpression Child<T>(string propertyName)
         {
             ChildInstanceExpression child = new ChildInstanceExpression(this, _memento, propertyName);
@@ -68,6 +83,11 @@ public ChildInstanceExpression Child<T>(string propertyName)
             return child;
         }
 
+        /// <summary>
+        /// Start the definition of a child instance for type T
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
         public ChildInstanceExpression Child<T>()
         {
             string propertyName = findPropertyName<T>();
@@ -104,7 +124,9 @@ internal InstanceTypeExpression TypeExpression()
             return new InstanceTypeExpression(this);
         }
 
-
+        /// <summary>
+        /// Helper class to capture the actual concrete type of an Instance
+        /// </summary>
         public class InstanceTypeExpression
         {
             private readonly InstanceExpression _parent;
@@ -114,12 +136,22 @@ internal InstanceTypeExpression(InstanceExpression parent)
                 _parent = parent;
             }
 
+            /// <summary>
+            /// Use type T for the concrete type of an instance
+            /// </summary>
+            /// <typeparam name="T"></typeparam>
+            /// <returns></returns>
             public InstanceExpression UsingConcreteType<T>()
             {
                 _parent._pluggedType = typeof (T);
                 return _parent;
             }
 
+            /// <summary>
+            /// Use a named Plugin type denoted by a [Pluggable("Key")] attribute
+            /// </summary>
+            /// <param name="concreteKey"></param>
+            /// <returns></returns>
             public InstanceExpression UsingConcreteTypeNamed(string concreteKey)
             {
                 _parent._memento.ConcreteKey = concreteKey;

Source/StructureMap/Configuration/DSL/LiteralExpression.cs

@@ -3,6 +3,10 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Small helper class to represent an object to be plugged into a PluginType as is
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class LiteralExpression<T> : MementoBuilder<LiteralExpression<T>>
     {
         private readonly T _target;

Source/StructureMap/Configuration/DSL/ProfileExpression.cs

@@ -3,6 +3,9 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Expression class to help define a runtime Profile
+    /// </summary>
     public class ProfileExpression : IExpression
     {
         private readonly string _profileName;
@@ -28,6 +31,11 @@ void IExpression.Configure(PluginGraph graph)
             }
         }
 
+        /// <summary>
+        /// Starts the definition of the default instance for the containing Profile
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
         public InstanceDefaultExpression For<T>()
         {
             InstanceDefaultExpression defaultExpression = new InstanceDefaultExpression(typeof (T), this);

Source/StructureMap/Configuration/DSL/PropertyExpression.cs

@@ -2,6 +2,9 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Defines the value of a primitive argument to a constructur argument
+    /// </summary>
     public class PropertyExpression
     {
         private readonly InstanceExpression _instance;
@@ -15,12 +18,23 @@ public PropertyExpression(InstanceExpression instance, MemoryInstanceMemento mem
             _propertyName = propertyName;
         }
 
+        /// <summary>
+        /// Sets the value of the constructor argument
+        /// </summary>
+        /// <param name="propertyValue"></param>
+        /// <returns></returns>
         public InstanceExpression EqualTo(object propertyValue)
         {
             _memento.SetProperty(_propertyName, propertyValue.ToString());
             return _instance;
         }
 
+        /// <summary>
+        /// Sets the value of the constructor argument to the key/value in the 
+        /// AppSettings
+        /// </summary>
+        /// <param name="appSettingKey"></param>
+        /// <returns></returns>
         public InstanceExpression EqualToAppSetting(string appSettingKey)
         {
             string propertyValue = ConfigurationManager.AppSettings[appSettingKey];

Source/StructureMap/Configuration/DSL/PrototypeExpression.cs

@@ -3,6 +3,10 @@
 
 namespace StructureMap.Configuration.DSL
 {
+    /// <summary>
+    /// Sets up a Prototype instance of type T
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
     public class PrototypeExpression<T> : MementoBuilder<PrototypeExpression<T>>
     {
         private readonly T _prototype;