# Conditional Instructions

> Validate forms in the Document Editor and Viewer with conditional instructions: Condition operators, And/Or groups, Instruction types and a booking form.

- **Product:** TX Text Control .NET Server
- **Section:** Documentation
- **Kind:** Topic
- **Path:** TX Text Control .NET Server > Document Processing > Conditional Instructions
- **9376 words**
- **Web URL:** https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/conditional-instructions/
- **LLMs URL:** https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/conditional-instructions/llms.txt
- **LLMs-Full URL:** https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/conditional-instructions/llms-full.txt

---

A booking request should accept only dates of the season, a number of nights between 2 and 14 and an accommodation that suits the size of the group. Conditional instructions are the rules that do this in a TX Text Control form: each one tests the values of form fields and, depending on the result, enables or disables fields, sets values, replaces the items of a drop-down list or marks a value as invalid. The rules are stored in the document and run while users fill out the form in the Document Editor or the Document Viewer.

What follows explains the parts of a rule, the comparisons each form field type supports, how conditions combine and when instructions run, and then builds the rules of a complete booking form. Form fields themselves are described in [Form Fields](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/form-fields/llms-full.txt).

### How Conditional Instructions Work

A conditional instruction has three parts:

- **A name.** It can't be empty and must be unique in the document.
- **One or more conditions.** Each condition compares the value of one form field with a comparison value, for example "the date of *Arrival* is on or after July 15".
- **One or more instructions.** Each instruction names a form field and what happens to it, for example "mark *Arrival* as valid". The field can be the one the conditions test or any other form field of the document.

When the conditions are fulfilled, every instruction is carried out. An instruction can also have an *else value*, which is applied when the conditions are not fulfilled. A rule is evaluated at two moments:

1. **When the document becomes a form.** A form is a document in the `ReadAndSelect` edit mode with read-only document permissions, as [Let Users Fill Out the Form](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-editor/form-fields/#let-users-fill-out-the-form) in the Document Editor describes. At that moment, all rules of the document are applied once. These are the *initial instructions*.
2. **When the value of a form field changes** that one of its conditions refers to. A check box changes when it is clicked. A date or selection form field changes when the user picks a date or an item, and a text, date or combo box field changes when the user has typed a new value and leaves the field. Typing alone, key by key, doesn't evaluate the rules.

In the class library, the four classes [Condition](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/llms-full.txt), [Instruction](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/llms-full.txt), [ConditionalInstruction](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstruction/llms-full.txt) and [ConditionalInstructionCollection](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/llms-full.txt) describe these parts. The sections below give the name of each setting in the dialog box and in the class library, so that the rules in the Document Editor and the reference can be read side by side.

### Where Conditional Instructions Run

| Component | What it does with conditional instructions |
|---|---|
| Document Editor | Users create, edit and remove them in the **Form Validation** group of the **Form Fields** tab. They are applied while form field validation is enabled and the document is a form. |
| Document Viewer | Applies the rules of a loaded form while users fill it out, as [Form Fields](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-viewer/form-fields/#how-forms-work-in-the-viewer) in the Document Viewer describes. |
| `ServerTextControl` | Loads and saves a document with its rules in the TX Text Control format, but can't read, add or apply them. |

In the Document Editor, your code turns form field validation on with [setIsFormFieldValidationEnabled](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/javascript/txtextcontrol/setisformfieldvalidationenabled-method/llms-full.txt) and reads the setting with [getIsFormFieldValidationEnabled](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/javascript/txtextcontrol/getisformfieldvalidationenabled-method/llms-full.txt). Add the following script below the editor in *Views/Home/Index.cshtml* of the [ASP.NET Core](https://docs.textcontrol.com/tx-text-control-dotnet-server/getting-started/document-editor/aspnet-core/llms-full.txt) tutorial:

```javascript
TXTextControl.addEventListener("documentLoaded", function () {
  // Apply the conditional instructions of every loaded form
  TXTextControl.setIsFormFieldValidationEnabled(true, function () {
    TXTextControl.getIsFormFieldValidationEnabled(function (enabled) {
      console.log("Form field validation: " + enabled);
    });
  });
});
```

#### On the Server

The class library documents [FormFieldCollection.ConditionalInstructions](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/formfieldcollection/conditionalinstructions-property/llms-full.txt), and with it [Add](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/add-method/llms-full.txt), [Remove](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/remove-method/llms-full.txt), [Clear](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/clear-method/llms-full.txt), [GetItem](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/getitem-method/llms-full.txt), [GetItems](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/getitems-method/llms-full.txt), [ConditionalInstructionNames](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/conditionalinstructionnames-property/llms-full.txt) and [Count](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstructioncollection/count-property/llms-full.txt). All of them work only while form field validation is enabled, a property of the `TextControl` of the Windows Forms and WPF products. When validation is off, `Count` returns -1, `ConditionalInstructionNames`, `GetItem` and `GetItems` return `null`, and `Add`, `Remove` and `Clear` return `false`.

`ServerTextControl` has no property that enables validation, so its collection stays locked, also for a loaded document that contains rules: with version 34.0 of the Core engine, `Count` returns -1 and `Add` returns `false`. The code samples of the desktop products, which add rules with `textControl1.FormFields.ConditionalInstructions.Add`, don't apply to `ServerTextControl`. The class [ServerVisualization.TextViewGenerator](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol-servervisualization/textviewgenerator/llms-full.txt), which is derived from `ServerTextControl`, has an [IsFormFieldValidationEnabled](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol-servervisualization/textviewgenerator/isformfieldvalidationenabled-property/llms-full.txt) property, `false` by default, which the reference describes as deciding whether conditional instructions are applied when its [EditMode](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol-servervisualization/textviewgenerator/editmode-property/llms-full.txt) is `ReadAndSelect` and its [DocumentPermissions](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol-servervisualization/textviewgenerator/documentpermissions-property/llms-full.txt) are read-only.

What the server does with forms that contain rules:

- **Keep them.** A form loaded and saved in the TX Text Control format (*.tx*) keeps its rules, so the server can merge data into a form template and pass it on to the Document Editor or the Document Viewer. Saved as DOCX, the form loses them.
- **Check the values itself.** Values that come back from the browser are checked by your server code, as [Read and Check the Values of a Filled Form](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/form-fields/#read-and-check-the-values-of-a-filled-form) shows.

### Create Rules in the Document Editor

The **Form Validation** group of the **Form Fields** tab has five buttons: **Enable Form Validation**, **Highlight Invalid Values**, **Previous Invalid Value**, **Next Invalid Value** and **Manage Conditional Instructions...**. The other buttons stay disabled until **Enable Form Validation** is on. The picture in [Form Field Types](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-editor/form-fields/#form-field-types) of the Document Editor shows the group.

1. Open the form and click **Enable Form Validation**.
2. Click **Manage Conditional Instructions...**. The dialog box lists the rules of the document. Create a rule, or select one and click **Edit...** to change it.
3. The **Conditional Instruction** dialog box has three sections:


    - **Name**: the unique name of the rule.
    - **Condition(s)**: in each row, the form field whose value is tested (a field without a name is listed under a generated unique name), the comparison operator and the comparison value. The ➕ button adds a row, and each row after the first is joined to the one before it with **And** or **Or**.
    - **Perform these actions**: in each row, the form field to change, the instruction and its value. The ➕ button adds a row. The button to the left of it opens the **Advanced Settings** dialog box of the instruction.

    ![The Windows Forms Conditional Instruction dialog box with the name Validate Arrival, two date conditions on Arrival joined by And, the open list of comparison value kinds Date, Year, Month and Day of the month, and the action Set value as valid.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/conditional-instr-dialog.a52daf74.webp)
4. Click **OK**. The rule is listed by its name.
5. Protect the document as a form, as [Let Users Fill Out the Form](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-editor/form-fields/#let-users-fill-out-the-form) describes, and save it in the TX Text Control format.

Before you protect the form, turn on **Highlight Invalid Values**, so that fields marked as invalid are highlighted. **Previous Invalid Value** and **Next Invalid Value** step through the invalid values of the form.

### Conditions for Each Form Field Type

The operators and values a condition offers depend on the type of the form field it tests. In the class library, a [Condition constructor](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/constructor/llms-full.txt) exists for each type, and the operator is a value of [Condition.ComparisonOperators](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/comparisonoperators-enumeration/llms-full.txt).

| Form field | Tests | Operators in the dialog box | Comparison values |
|---|---|---|---|
| Check box (`CheckFormField`) | `Checked` | **Is**, **Is not** | **Checked**, **Unchecked** |
| Text box (`TextFormField`) | `Text` | **Is**, **Is not**, **Contains**, **Starts with**, **Ends with**, **Does not contain**, **Does not start with**, **Does not end with**, **Is greater than**, **Is greater than or equal**, **Is less than**, **Is less than or equal**, **Matches regular expression**, **Does not match regular expression** | A text, or **Empty (no value set)** |
| Drop-down list or combo box (`SelectionFormField`) | `Text` | As for text boxes | A text, **Empty (no value set)**, one of the items, or **A list item** |
| Date (`DateFormField`) | `Date` | **Is**/**Is in**, **Is not**/**Is not in**, **After**, **Is on or after**, **Before**, **Is on or before** | A date, a year, a month, a day of the month, a weekday, or **Empty (no value set)** |

**Empty (no value set)** tests whether the field has no value: a text box or selection form field without text, or a date field without a date. It works with **Is** and **Is not** only, and not for check boxes. In code, the comparison value is `null` (or an empty string for text).

#### Check Boxes

A check box condition tests one of two states. In the class library, the constructor takes the check box and a `bool`: `true` stands for **Is Checked**, `false` for **Is not Checked**.

![A condition row of the Windows Forms Conditional Instruction dialog box that tests whether checkFormField1 Is Checked.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/condition-check-box-checked.946cbaff.webp)

#### Text Boxes and Selection Form Fields

Text and selection form fields are compared by their text in three ways:

- **Text comparison.** **Is** and **Is not** compare the whole text, **Contains** and **Does not contain** look for a part of it, and the **Starts with** and **Ends with** operators test the beginning and the end.
- **Greater and less.** **Is greater than**, **Is greater than or equal**, **Is less than** and **Is less than or equal** compare numbers when both the text and the comparison value are numbers, decimal numbers included. Otherwise, they compare the strings in alphabetical order, case-sensitively. Numbers are read with the culture of the current thread (`Thread.CurrentThread.CurrentCulture`): with English settings, "1.0" is the number 1, but with German settings, where the comma separates decimals, the period is ignored and "1.0" is 10.
- **Regular expressions.** **Matches regular expression** and **Does not match regular expression** test the text against a pattern of the .NET regular expression engine. In the class library, this is the operator `Is` or `IsNot` with the flag `Regex` of [Condition.TextComparisonFlags](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/textcomparisonflags-enumeration/llms-full.txt); the default flag `CustomText` compares plain text.

![Four condition rows of the Windows Forms Conditional Instruction dialog box joined by And that test a text form field: Contains @, Does not start with @, Ends with .com and Does not end with @.com.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/condition-email-address.388721c4.webp)

#### Items of Selection Form Fields

A selection form field can also be compared with its items, set with the flags of [Condition.ItemComparisonFlags](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/itemcomparisonflags-enumeration/llms-full.txt):

- **One of the items** (`SpecificItem`) compares the text with the text of that item, with any operator except the two regular expression operators. Unlike a plain text comparison, the condition is fulfilled only while the field still has an item with this text, and in code, the constructor throws an `ArgumentException` when the value isn't one of the items.
- **A list item** (`AnyItem`) tests whether the text equals any of the items. It works with **Is** and **Is not** only, and the comparison value is ignored. With **Is**, the condition is fulfilled as soon as the user selects an item, and not fulfilled while the field is empty or shows typed text that isn't an item.

![The Windows Forms Conditional Instruction dialog box with the condition Number of Travelers Is and the open list of comparison values: the items 1 to 8, Empty (no value set) and A list item.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/condition-list-item-menu.12f7ec47.webp)

![Two condition rows of the Windows Forms Conditional Instruction dialog box for a drop-down list: Is not the item XS, And Is greater than or equals the item XL, with the items XS to XXXL open.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/condition-clothing-sizes.e6b3dba9.webp)

#### Date Form Fields

A date condition compares the date of the field with one of five kinds of values, which the constructor takes as different types:

| Value | Type in the class library | Operators |
|---|---|---|
| A date | `DateTime` | All six |
| A year from 1601 to 9999 | `int` | All six |
| A month | [Condition.Month](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/month-enumeration/llms-full.txt), such as `Condition.Month.December` | All six |
| A day of the month from 1 to 31 | `int` | All six |
| A weekday | `System.DayOfWeek` | **Is**, **Is not** |

In the class library, **After** and **Is on or after** are `IsGreaterThan` and `IsGreaterThanOrEqual`, and **Before** and **Is on or before** are `IsLessThan` and `IsLessThanOrEqual`. [Condition.ComparisonValueType](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/comparisonvaluetype-property/llms-full.txt) returns how a condition interprets its value, as a value of [Condition.ComparisonValueTypes](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/comparisonvaluetypes-enumeration/llms-full.txt).

![Three condition rows of the Windows Forms Conditional Instruction dialog box joined by And that test a date form field: the weekday Is Monday, the month Is May and the day of the month Is on or after 25.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/condition-last-monday-may.265b5935.webp)

### Combine Conditions With And and Or

Each condition after the first is joined to the one before it by a logical connective, set with [Condition.LogicalConnective](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/logicalconnective-property/llms-full.txt) and the values `And` and `Or` of [Condition.LogicalConnectives](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/condition/logicalconnectives-enumeration/llms-full.txt). The default is `And`, and the connective of the first condition is ignored. The conditions are tested in the order in which they appear in the rule.

**And binds more strongly than Or.** Conditions joined by **And** form a group that is fulfilled when all of its conditions are, and **Or** joins such groups:

```text
C1 And C2 Or C3         means   (C1 And C2) Or C3
C1 Or C2 And C3         means   C1 Or (C2 And C3)
```

![Three check box conditions in the Windows Forms Conditional Instruction dialog box, checkFormField1 Is Checked, Or checkFormField2 Is Checked, And checkFormField3 Is Checked, with parentheses around the last two conditions.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/condition-and-or-groups.c11b1659.webp)

There are no parentheses. To test `C1 And (C2 Or C3)`, repeat the shared condition in each group:

```text
C1 And C2 Or C1 And C3  means   (C1 And C2) Or (C1 And C3)
```

In the class library, the same `Condition` object may appear several times in the [Conditions](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstruction/conditions-property/llms-full.txt) array of a rule. Give it the connective `Or` and put it first: the first occurrence ignores its connective, and every later one starts a new group.

### Instruction Types

An instruction changes one form field. In the class library, its type is a value of [Instruction.InstructionTypes](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/instructiontypes-enumeration/llms-full.txt), and the [Instruction constructor](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/constructor/llms-full.txt) takes the field, the type, the value and, optionally, the else value:

| In the dialog box | `InstructionTypes` | Value | Form fields |
|---|---|---|---|
| **Allow editing**, **Deny editing** | `IsEnabled` | `bool`, the new value of `FormField.Enabled` | All |
| **Set value as valid**, **Set value as invalid** | `IsValueValid` | `bool`, `true` for valid | All |
| **Set new value** | `SetValue` | `bool` for a check box (**Checked** or **Unchecked**), a string or an item for text and selection form fields, a `DateTime` for a date field; `null` or **Empty (no value set)** removes the value of all but check boxes | All |
| **Set new items** | `SetItems` | `string[]` that replaces the `Items` of the field; `null` or an empty array removes all items | Selection form fields |

![Three Set new value instructions in the Windows Forms Conditional Instruction dialog box: a combo box set to Empty (no value set), a drop-down list set to Product Number and a second drop-down list whose open list of items has TX Spell selected.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/instruction-set-new-value.db86d2cb.webp)

In the dialog box, **Specify items to set...** next to **Set new items** opens the **Edit Items** dialog box, in which you enter the new items. An item can't be an empty string, and removing all items from the list creates an instruction that empties the drop-down list.

![The Windows Forms Conditional Instruction dialog box with the instruction Set new items for comboBox and the Edit Items dialog box that lists Text Control, TX Spell and TX Barcode.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/instruction-edit-items.c37ada93.webp)

A rule can change several fields, and one field several times, but not twice with the same instruction type: the constructor of [ConditionalInstruction](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstruction/constructor/llms-full.txt) and its [Instructions](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/conditionalinstruction/instructions-property/llms-full.txt) property throw an `ArgumentException` for two instructions of the same type for the same form field.

### Else Instructions

An else instruction sets a value when the conditions of the rule are not fulfilled. The dialog box and the class library differ here:

- **The dialog box** adds an else instruction with the opposite value to **Allow editing**, **Deny editing**, **Set value as valid** and **Set value as invalid**. A rule that marks a field as valid therefore marks it as invalid when its conditions are not met. **Set new value** and **Set new items** get no else instruction by themselves.
- **The class library** never adds one. The constructor with four parameters sets the else value and turns [IsElseInstructionEnabled](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/iselseinstructionenabled-property/llms-full.txt) on; with three parameters, it's off.

In the **Advanced Settings** dialog box of an instruction, the check box **In case the condition is not fulfilled, set the value to** turns the else instruction on or off, and the value next to it sets it. [ElseInstructionValue](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/elseinstructionvalue-property/llms-full.txt) returns the else value. When none was set, it returns a default: the negation of the value for `IsEnabled`, `IsValueValid` and check boxes, an empty string for text and selection form fields, `null` for date fields and an empty array for `SetItems`.

![The Advanced Settings dialog box of an instruction with the check boxes Is initial instruction, Perform instruction on form field value changes and In case the condition is not fulfilled, set the value to, and the value Set value as valid.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/instruction-advanced-dialog.4ba2f031.webp)

### Initial and Change Instructions

By default, an instruction runs at both moments: when the document becomes a form, and when a tested field changes. Two properties, both `true` by default, switch one of the moments off for a single instruction:

| Property | Check box in Advanced Settings | Set to `false` when |
|---|---|---|
| [IsInitialInstruction](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/isinitialinstruction-property/llms-full.txt) | **Is initial instruction** | The instruction must not run when the form opens, for example because its conditions are fulfilled by the empty form. |
| [IsFormFieldChangeInstruction](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/txtextcontrol/instruction/isformfieldchangeinstruction-property/llms-full.txt) | **Perform instruction on form field value changes** | The instruction must run only when the form opens and ignore what users enter. |

### Invalid Values

An instruction of the type `IsValueValid` marks a form field value as valid or invalid; the value itself doesn't change. In the Document Editor, **Highlight Invalid Values** highlights the invalid values of a form, and **Previous Invalid Value** and **Next Invalid Value** step through them. The Document Viewer highlights required fields that aren't valid, and its [forms.validate](https://docs.textcontrol.com/tx-text-control-dotnet-server/reference/javascript-document-viewer/forms/validate-method/llms-full.txt) method returns `false` while required fields are missing, as [Validate and Submit the Values](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-viewer/form-fields/#validate-and-submit-the-values) shows.

### Example: A Booking Request Form

The sample form *travel-form.tx* is installed with TX Text Control .NET Server in *C:\\Program Files\\Text Control GmbH\\TX Text Control 34.0.NET Server for ASP.NET\\Samples\\Demo*. It has four form fields:

| Name | Type | Content |
|---|---|---|
| Arrival | Date form field | The date of arrival |
| Number of Nights | Text form field | The length of the stay |
| Number of Travelers | Selection form field, drop-down list | The items 1 to 8 |
| Desired Accommodation | Selection form field, drop-down list | The accommodation |

![The booking request form template with the fields Arrival, Number of Nights, Number of Travelers and Desired Accommodation, the notes on the allowed values next to them, and its 2020 date range.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/booking-form-template.411cc62c.webp)

The form must behave as follows:

- Every field is required. A field without a value is invalid.
- Arrival is valid from July 15 to November 15, 2020.
- Number of Nights accepts whole numbers from 2 to 14.
- Desired Accommodation is disabled until a number of travelers is selected. It is invalid only while it is enabled and empty.
- Groups of 5 or more can choose *Apartment Belle View* and *Ocean View Suite*. Groups of up to 4 can also choose *King's Life Suite* and *Tree House Room*. If the group grows to 5 or more after one of these two was chosen, the choice is removed.

Seven rules implement this. Create each in the **Conditional Instruction** dialog box of the Document Editor; the lists give the settings of the dialog box, and the class library values in parentheses.

#### 1. Validate Arrival

- **Conditions:** Arrival **Is on or after** 7/15/2020 (`IsGreaterThanOrEqual`, `new DateTime(2020, 7, 15)`), **And** Arrival **Is on or before** 11/15/2020 (`IsLessThanOrEqual`).
- **Instruction:** Arrival, **Set value as valid** (`IsValueValid`, `true`), with the else instruction **Set value as invalid** (`false`) that the dialog box adds.

A missing date doesn't fulfill the conditions, so the else instruction marks it as invalid too.

#### 2. Validate Number of Nights

This rule tests for invalid values instead of valid ones:

- **Conditions:** Number of Nights **Is less than** 2 (`IsLessThan`, `"2"`), **Or** **Is greater than** 14 (`IsGreaterThan`, `"14"`), **Or** **Does not match regular expression** `^\d+$` (`IsNot` with `TextComparisonFlags.Regex`).
- **Instruction:** Number of Nights, **Set value as invalid** (`IsValueValid`, `false`), with the else instruction **Set value as valid** (`true`).

The regular expression accepts only digits, so an empty field, a decimal number or text is invalid. All three conditions are joined by **Or**, so one of them is enough.

![The Windows Forms Conditional Instruction dialog box with the rule Validate Number of Nights: Is less than 2, Or Is greater than 14, Or Does not match regular expression ^\d+$, and the open list of instructions with Set value as invalid selected.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/rule-validate-nights.823491cb.webp)

#### 3. Validate Number of Travelers

- **Condition:** Number of Travelers **Is** **Empty (no value set)** (`Is`, `null`).
- **Instruction:** Number of Travelers, **Set value as invalid** (`false`), with the else instruction **Set value as valid** (`true`).

A drop-down list shows only its items, so the field is valid as soon as the user selects one. The condition Number of Travelers **Is** **A list item** (`Is`, `ItemComparisonFlags.AnyItem`) with **Set value as valid** does the same from the other side.

![The Windows Forms Conditional Instruction dialog box with the rule Validate Number of Travelers: Number of Travelers Is Empty (no value set), and the instruction Set value as invalid.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/rule-validate-travelers.4285d167.webp)

#### 4. Validate Desired Accommodation

Two fields take part, so the rule is evaluated when either of them changes:

- **Conditions:** Number of Travelers **Is** **A list item** (`Is`, `AnyItem`), **And** Desired Accommodation **Is** **Empty (no value set)** (`Is`, `null`).
- **Instruction:** Desired Accommodation, **Set value as invalid** (`false`), with the else instruction **Set value as valid** (`true`).

![The Windows Forms Conditional Instruction dialog box with the rule Validate Desired Accommodation: Number of Travelers Is A list item, And Desired Accommodation Is Empty (no value set), and the instruction Set value as invalid.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/rule-validate-accommodation.aa5d5c5e.webp)

#### 5. Enable/Disable Desired Accommodation

- **Condition:** Number of Travelers **Is** **Empty (no value set)**.
- **Instruction:** Desired Accommodation, **Deny editing** (`IsEnabled`, `false`), with the else instruction **Allow editing** (`true`).

![The Windows Forms Conditional Instruction dialog box with the rule Enable/Disable Desired Accommodation: Number of Travelers Is Empty (no value set), and the instruction Deny editing for Desired Accommodation.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/rule-disable-accommodation.2184fe62.webp)

#### 6. Update Desired Accommodation Items

- **Condition:** Number of Travelers **Is greater than or equal** the item 5 (`IsGreaterThanOrEqual`, `"5"`, `ItemComparisonFlags.SpecificItem`). The items are numbers, so they are compared as numbers.
- **Instruction:** Desired Accommodation, **Set new items** (`SetItems`) with *Apartment Belle View* and *Ocean View Suite*. In **Advanced Settings**, turn on the else instruction and set all four accommodations with **Specify items to set...**.

![The Windows Forms Conditional Instruction dialog box with the rule Update Desired Accommodation Items, the condition Number of Travelers Is greater than or equals 5, and the Edit Items dialog box with Apartment Belle View and Ocean View Suite.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/rule-accommodation-items.c5280bd8.webp)

In the class library, the instruction is:

```csharp
Instruction setItems = new Instruction(desiredAccommodation, Instruction.InstructionTypes.SetItems,
    new string[] { "Apartment Belle View", "Ocean View Suite" },
    new string[] { "King's Life Suite", "Tree House Room", "Apartment Belle View", "Ocean View Suite" });
```

#### 7. Reset Desired Accommodation

The choice is removed when the group has 5 or more travelers **and** the accommodation is King's Life Suite **or** Tree House Room. Because **And** binds more strongly than **Or**, the travelers condition is repeated in both groups:

- **Conditions:** Number of Travelers **Is greater than or equal** the item 5, **And** Desired Accommodation **Is** King's Life Suite, **Or** Number of Travelers **Is greater than or equal** the item 5, **And** Desired Accommodation **Is** Tree House Room.
- **Instruction:** Desired Accommodation, **Set new value** **Empty (no value set)** (`SetValue`, `null`), without an else instruction.

![The Windows Forms Conditional Instruction dialog box with the rule Reset Desired Accommodation: two groups in parentheses joined by Or, each Number of Travelers Is greater than or equals 5 And Desired Accommodation Is King's Life Suite or Tree House Room, and the instruction Set new value Empty (no value set).](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/rule-reset-accommodation.8b35df6e.webp)

Both accommodation conditions compare plain text, not an item: once rule 6 has replaced the items, King's Life Suite is no longer one of them, and a condition on that item would never be fulfilled. In the class library, the conditions are:

```csharp
Condition fiveOrMore = new Condition(numberOfTravelers, Condition.ComparisonOperators.IsGreaterThanOrEqual,
    "5", Condition.ItemComparisonFlags.SpecificItem)
{
    LogicalConnective = Condition.LogicalConnectives.Or
};

Condition kingsLifeSuite = new Condition(desiredAccommodation, Condition.ComparisonOperators.Is, "King's Life Suite");
Condition treeHouseRoom = new Condition(desiredAccommodation, Condition.ComparisonOperators.Is, "Tree House Room");

Condition[] conditions = { fiveOrMore, kingsLifeSuite, fiveOrMore, treeHouseRoom };
```

`fiveOrMore` appears twice with the connective `Or`: at the first position, the connective is ignored, and at the third position, it starts the second group.

#### The Form in Use

When the form is protected, the initial instructions run. Arrival, Number of Nights and Number of Travelers are marked as invalid because they are empty. Desired Accommodation is disabled by rule 5, but not marked as invalid, because rule 4 requires a selected number of travelers.

As the user fills out the form, the rules follow each change. A date before July 15 keeps Arrival invalid, and "2.5" nights stays invalid because of the regular expression. Selecting 3 travelers enables Desired Accommodation and marks it as invalid until an accommodation is chosen. If the user then changes the number of travelers from 3 to 6 after choosing King's Life Suite, rule 7 empties Desired Accommodation, rule 4 marks it as invalid and rule 6 leaves only the two accommodations for larger groups.

![The protected booking request form with the arrival 7/14/2020, 2.5 nights, 3 travelers and King's Life Suite, the invalid date and number of nights highlighted.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/booking-form-invalid-values.88b9b460.webp)

![The same form after the number of travelers was changed to 6: Desired Accommodation is empty and highlighted as invalid.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/booking-form-six-travelers.f7ad3d55.webp)

![The booking request form filled out with valid values: the arrival 8/20/2020, 12 nights, 6 travelers and Ocean View Suite.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/booking-form-completed.2330e7e5.webp)

### More Condition Examples

| Goal | Conditions |
|---|---|
| Check box 1 is checked | cb1 **Is** Checked (`new Condition(cb1, true)`) |
| Both check boxes are unchecked | cb1 **Is not** Checked **And** cb2 **Is not** Checked |
| At least one check box is checked | cb1 **Is** Checked **Or** cb2 **Is** Checked |
| Check box 1, or both 2 and 3, are checked | cb1 **Is** Checked **Or** cb2 **Is** Checked **And** cb3 **Is** Checked |
| A text box isn't empty | **Is not** **Empty (no value set)** |
| The state Colorado | **Is** "Colorado" **Or** **Is** "CO" |
| A simple .com e-mail address | **Contains** "@" **And** **Does not start with** "@" **And** **Ends with** ".com" **And** **Does not end with** "@.com" |
| A positive number | **Is greater than** "0" |
| A number from 0 to 18 | **Is greater than or equal** "0" **And** **Is less than or equal** "18" |
| Text starting with a, b or c in either case | **Is greater than or equal** "a" **And** **Is less than** "d" **Or** **Is greater than or equal** "A" **And** **Is less than** "D" |
| 5 to 8 characters | **Matches regular expression** `^.{5,8}$` |
| No digits and no white space | **Does not match regular expression** `[\s\d]+` |
| The item "Economy class basic" is selected | **Is** the item "Economy class basic" |
| A subcategory of the item "Economy class" | **Is not** the item "Economy class" **And** **Contains** the item "Economy class" |
| A clothing size from XL to XXXL | **Is not** the item "XS" **And** **Is greater than or equal** the item "XL" |
| The text of a combo box is one of its items | **Is** **A list item** |
| No date | **Is** **Empty (no value set)** |
| Any date but March 11, 2027 | **Is not** 3/11/2027 |
| Before March 11, 2027 | **Before** 3/11/2027 |
| From December 24, 2027 to January 1, 2028 | **Is on or after** 12/24/2027 **And** **Is on or before** 1/1/2028 |
| December 25 of any year | **Is** December **And** **Is** day 25 |
| The fourth Thursday of November | **Is** November **And** **Is** Thursday **And** **Is on or after** day 22 **And** **Is on or before** day 28 |
| The last Monday of May | **Is** Monday **And** **Is** May **And** **Is on or after** day 25 |
| A weekend | **Is** Saturday **Or** **Is** Sunday |
| A working day | **Is not** Saturday **And** **Is not** Sunday |
| Every Monday of 2027 | **Is** year 2027 **And** **Is** Monday |
| Every weekend of 2027 | **Is** year 2027 **And** **Is** Saturday **Or** **Is** year 2027 **And** **Is** Sunday |

The last week of a month starts on the 25th in months with 31 days, on the 24th in months with 30 days and on the 22nd in February, or the 23rd in a leap year. Comparisons of text are case-sensitive, which is why the a-to-c example needs a group for each case.

Regular expressions for common values, for **Matches regular expression**:

```text
Credit card number          ^((4\d{3})|(5[1-5]\d{2})|(6011))-?\d{4}-?\d{4}-?\d{4}|3[4,7]\d{13}$
E-mail address              ^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
US social security number   ^\d{3}-\d{2}-\d{4}$
US telephone number         ^[2-9]\d{2}-\d{3}-\d{4}$
US ZIP code                 ^(?!0{5})(\d{5})(?!-?0{4})(|-\d{4})?$
```

### More Instruction Examples

- **Reset a field.** To disable a field, remove its value and clear an invalid mark when a condition is met, use three instructions for the field: **Deny editing** with its else instruction **Allow editing**; **Set new value** **Empty (no value set)**; and **Set value as valid** with its else instruction turned off in **Advanced Settings**, because another rule decides when the field is invalid. Clear **Is initial instruction** for all three, as the reset isn't needed when the form opens. A check box can't be empty, so its reset value is **Checked** or **Unchecked**.
- **Mark an empty combo box as invalid when the form opens.** Choose a condition that the new form fulfills, such as the combo box **Is** **Empty (no value set)**, and the instruction **Set value as invalid** with the else instruction turned off. Clear **Perform instruction on form field value changes**, so that another rule, which validates what the user enters, isn't overridden (`IsFormFieldChangeInstruction` `false`).
- **Set a value from an item.** **Set new value** can set a selection form field to one of its items, or to any text in a combo box.

![Three instructions for textFormField in the Windows Forms dialog box, Deny editing, Set new value Empty (no value set) and Set value as valid, and the Advanced Settings of the second with Is initial instruction and the else instruction cleared.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/instruction-reset-field.74ebd3ab.webp)

![The instruction Set value as invalid for comboBox with its Advanced Settings: Is initial instruction checked, Perform instruction on form field value changes and the else instruction cleared.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/instruction-invalid-on-open.4e448f71.webp)

### Radio Button Groups

A radio button group, in which users select exactly one option, is built from check boxes that show radio button characters and start unchecked, as [Conditional Instructions and Radio Button Groups](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/form-fields/#conditional-instructions-and-radio-button-groups) shows. For each button, two rules create the group behavior:

| Rule | Condition | Instruction |
|---|---|---|
| Button 1 Checked | button 1 **Is** Checked | button 2 (and every other button), **Set new value** **Unchecked** |
| Button 1 Unchecked | button 1 **Is not** Checked | button 1, **Set new value** **Checked**, with **Is initial instruction** cleared |

The second rule keeps a selected option from being cleared. It must not be an initial instruction: when the form opens, all buttons are unchecked, and each of these rules would check its button, so the button handled last would appear selected.

![The Windows Forms Conditional Instruction dialog box with the rule Radio Button 1 Checked: radioButton1 Is Checked, and the instruction Set new value Unchecked for radioButton2.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/radio-button-checked-rule.481a1974.webp)

![The rule Radio Button 1 Unchecked: radioButton1 Is not Checked, the instruction Set new value Checked for radioButton1, and its Advanced Settings with Is initial instruction cleared.](https://docs.textcontrol.com/assets/img/tx-text-control-dotnet-server/radio-button-unchecked-rule.3dcbeaf2.webp)

### Next Steps

- [Form Fields](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/form-fields/llms-full.txt): create forms, read their values and flatten them on the server.
- [Form Fields](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-editor/form-fields/llms-full.txt) in the Document Editor: design and protect forms in the browser.
- [Form Fields](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-viewer/form-fields/llms-full.txt) in the Document Viewer: let users fill out and submit forms with their rules.
- [Events](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-editor/events/llms-full.txt) of the Document Editor: the form field change events.

---

## Nearby

- **Previous:** [Events](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/events/llms-full.txt)
- **Next:** [XML Documents](https://docs.textcontrol.com/tx-text-control-dotnet-server/document-processing/xml/llms-full.txt)