To ensure all fields are marked dirty, you have two options:

this.form.markAsDirty();

Alternatively, you can mark each individual field using the following code snippet:

Object.keys(this.form.controls).forEach(key => {
  this.form.get(key).markAsDirty();
});

A more concise way to make all form controls dirty, inspired by Sachin Gupta:

public static markAllControlsAsDirty(controls: AbstractControl[]): void {
    controls.forEach(control => {
      if (control instanceof FormControl) {
        (control as FormControl).markAsDirty({onlySelf: true});
      } else if (control instanceof FormGroup) {
        this.markAllControlsAsDirty(Object.values((control as FormGroup).controls));
      } else if (control instanceof FormArray) {
        this.markAllControlsAsDirty((control as FormArray).controls);
      }
    });
  }

To implement it, simply call:

FormUtils.markAllControlsAsDirty(Object.values(this.form.controls));

Optimal method to follow :

To ensure all controls are marked as dirty: this.form.markAsDirty();

An alternative way to achieve this (second option):

let controlList = this.form.controls;

    controlList.forEach(control => {
          this.form.get(control).markAsDirty();
        });

An enhanced version of Nicolas Ay's approach:

Organize a utils file specifically for forms and export Nicolas's solution from there

/**
 * Sets all controls and their nested controls as dirty.
 * @param abstractControls - an array of controls (FormControls, FormGroups, or FormArrays)
 */
export function markAllControlsAsDirty(abstractControls: AbstractControl[]): void {
  abstractControls.forEach((abstractControl) => {
    if (abstractControl instanceof FormControl) { 
      (abstractControl as FormControl).markAsDirty({ onlySelf: true });
    } else if (abstractControl instanceof FormGroup) {
      markAllControlsAsDirty(
        Object.values((abstractControl as FormGroup).controls)
      );
    } else if (abstractControl instanceof FormArray) {
      markAllControlsAsDirty((abstractControl as FormArray).controls);
    }
  });
}

You can now easily utilize this function within the application by simply calling it like so:

markAllControlsAsDirty([form]);

Identify and mark dirty controls (those with values) within a FormGroup

function markDirtyControlsWithValue(form: FormGroup): void {
  const findAndMark = (group: FormGroup) => {
    Object.keys(group.controls).forEach(key => {
      const control = group.get(key);
      if (control.value !== null && control.value !== undefined && control.value !== '') {
        control.markAsDirty();
      }
      if (control instanceof FormGroup) {
        findAndMark(control);
      }
    });
  };
  findAndMark(form);
}

The current version (12) includes a method called markAllAsTouched, but it does not have a similar method for marking all controls as dirty on the abstractControl.

Here is an example function that sets the dirty state for all formControls:

function setAllControlsDirty<T extends AbstractControl>(control: T): void {
  if (control instanceof FormGroup) {
    const controls = control.controls;
    
    Object.keys(controls).forEach(key => {
      controls[key].markAsDirty();
      setAllControlsDirty(controls[key]);
    });
  } else if (control instanceof FormArray) {
    control.controls.forEach(formControl => formControl.markAsDirty());
  } else if (control instanceof FormControl) {
    control.markAsDirty();
  } else {
    throw new Error('Error: unexpected control type');
  }
}

For those utilizing Angular18+ and looking for an update based on @Sachin Gupta's answer, I encountered a situation where his solution did not work for me initially. It turns out that constructor.name on FormControl was returning FormControl2 for some unknown reason. To address this issue, I created a utility class:

import { AbstractControl, FormArray, FormControl, FormGroup } from "@angular/forms";

export class FMWFormControlUtils {
    static isValid(control: AbstractControl) {
        return control.valid
            && !control.pristine
            && (control.touched)
            && control.status != 'DISABLED'
            && control.status != 'PENDING';
    }

    static markGroupDirty(formGroup: FormGroup) {
        Object.keys(formGroup.controls).forEach((key) => {
            const name = formGroup.get(key)!.constructor.name;
            if (name.includes('FormGroup')) {
                this.markGroupDirty(formGroup.get(key) as FormGroup);
            }
            if (name.includes('FormArray')) {
                this.markArrayDirty(formGroup.get(key) as FormArray);
            }
            if (name.includes('FormControl')) {
                this.markControlDirty(formGroup.get(key) as FormControl);
            }
        });
    }
    static markArrayDirty(formArray: FormArray) {
        formArray.controls.forEach((control) => {
            const name = control.constructor.name
            if (name.includes('FormGroup')) {
                this.markGroupDirty(control as FormGroup);
            }
            if (name.includes('FormArray')) {
                this.markArrayDirty(control as FormArray);
            }
            if (name.includes('FormControl')) {
                this.markControlDirty(control as FormControl);
            }
        });
    }
    static markControlDirty(formControl: FormControl) {
        formControl.markAsDirty();
    }
}