add example for multiple ifs on the same prop

Author: gregsdennis

_docs/schema/schemagen/conditional-generation.md

@@ -64,6 +64,8 @@ The `[If]` attribute creates a condition involving a discrete value.  It takes t
 - `value` - This is the expected value for the property you named above.  The condition will apply when the property equals this value.  The value can be any compiler-constant value, but really should be JSON-compatible.  So strings, numbers, and booleans are generally best.  Enum values will work, too, but `[IfEnum]` may be a better option if you're using an enum property.
 - `group` - This is a key that identifies a group for this condition.  It can be any compiler-constant value.
 
+On its own, a single `[If]` attribute will create an `if` keyword containing a `const` keyword and the value you specify.  However, the attribute can also be repeated with different values under the same group in order to create an `enum` keyword containing all of the values in that group.  An example of the `enum` generation can be found here.  (Note that this is slightly different from the [`[IfEnum]`](#ifenum-attribute) described below.)
+
 #### Example {#if-example}
 
 The example starts by defining a person which contains a couple properties that we want to constrain conditionally.

_docs/schema/schemagen/examples/multiple-ifs-one-group.md

@@ -0,0 +1,123 @@
+---
+layout: page
+title: Using Multiple [If] Attributes in a Single Group
+bookmark: Stacking Ifs
+permalink: /schema/examples/:title/
+icon: fas fa-tag
+order: "01.5.2.5"
+---
+This example shows how multiple `[If]` attributes can be combined to create "OR" logic.
+
+Suppose we have the following model
+
+```c#
+class CarColors
+{
+    public string Interior { get; set; }
+    public string Exterior { get; set; }
+}
+```
+
+Now let's say that there is a requirement that if the exterior color is white or black, the interior needs to be gray; otherwise, the interior can be any other color.
+
+## The standard way
+
+In normal usage, we could create two condition groups: one for white and one for black.  We would the apply constraints under those conditions.
+
+```c#
+[If(nameof(Exterior, "white", "isWhite"))]
+[If(nameof(Exterior, "black", "isBlack"))]
+class CarColors
+{
+    [Const("gray", ConditionGroup = "isWhite")]
+    [Const("gray", ConditionGroup = "isBlack")]
+    public string Interior { get; set; }
+    public string Exterior { get; set; }
+}
+```
+
+This would create the schema:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "Interior": { "type": "string" },
+    "Exterior": { "type": "string" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "Exterior": { "const": "white" }
+        },
+        "required": [ "Exterior" ]
+      },
+      "then": {
+        "properties": {
+          "Interior": { "const": "gray" }
+        }
+      }
+    },
+    {
+      "if": {
+        "properties": {
+          "Exterior": { "const": "black" }
+        },
+        "required": [ "Exterior" ]
+      },
+      "then": {
+        "properties": {
+          "Interior": { "const": "gray" }
+        }
+      }
+    }
+  ]
+}
+```
+
+This is fine.  But notice how the `then` constraint sets are the same.  It'd be better if the conditions could be combined to check if `Exterior` is _either_ `"white"` or `"black"` and just have a single `then`.
+
+## Combining conditions
+
+To do this, we just need to specify the same group in the appropriate `[If]` attributes.
+
+```c#
+[If(nameof(Exterior, "white", "grayRequirement"))]
+[If(nameof(Exterior, "black", "grayRequirement"))]
+class CarColors
+{
+    [Const("gray", ConditionGroup = "grayRequirement")]
+    public string Interior { get; set; }
+    public string Exterior { get; set; }
+}
+```
+
+This will collect all of the possible values for that property and render them under an `enum` instead of a `const`.
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "Interior": { "type": "string" },
+    "Exterior": { "type": "string" }
+  },
+  "allOf": [
+    {
+      "if": {
+        "properties": {
+          "Exterior": { "enum": [ "white", "black" ] }
+        },
+        "required": [ "Exterior" ]
+      },
+      "then": {
+        "properties": {
+          "Interior": { "const": "gray" }
+        }
+      }
+    }
+  ]
+}
+```
+
+This is a much more concise schema that better expresses the requirement.