Create "Programmer-Style" Class-Based DSC Resources

With Windows Management Framework (WMF) 4.0, Microsoft introduced a new configuration management platform built on Windows PowerShell called Desired State Configuration (DSC/0. DSC evolved with new features in WMF 5.0, one of which introduced class-based DSC resources — a way for programmers familiar with object-oriented programming to use classes to create resources to configure systems. This article will get you started programming your own class-based resources.


Resources are the key building block to writing DSC configurations. As a result, some basic resources, such as files and registry settings, come built into PowerShell and reside in the PSDesiredStateConfiguration module. Beyond those basic items, you’ll need to rely on custom resources for configuring more advanced components or settings.

The PowerShell Gallery contains Microsoft- and community-written DSC resources to cover a wide range of advanced configuration scenarios. This should be your first stop for a custom resource, after all, why reinvent the wheel?  However, if you find no custom resource for a configuration task, then it’s on to writing your own.

Custom Resources in a Nutshell

You can build custom resources using one of two programming styles — function-based resources and class-based resources. Each has its own benefits and shortcomings, and it’s important to understand the differences between the two to decide which to use for your resources.

Function-based DSC resources require a set folder structure and set of files. In order for the resource to work correctly, the files and folders must be named exactly as the Microsoft documentation states. Creating a schema.mof file defines the list of properties that the resource can configure.  In addition, you must include the 3 required functions — get-TargetResource, test-TargetResource, and set-TargetResource. Lastly, you also need to version function-based resources, and the version folders are part of the folder structure.

Class-based DSC resources, on the other hand, are simply organized just like a regular PowerShell module. First, a folder with the name of the resource contains two files — a PowerShell module (.psm1) and a module manifest (.psd1). Second, similar to the function-based resource, it also contains 3 methods — get(), set(), and test(). There are no other folders or files, which is a benefit. When WMF 5.0 was first released, class-based resources did not support versioning for use on a pull server, but that shortcoming appears to be resolved in newer versions of WMF 5.1.

Class-Based Resources

WMF 5.0 first introduced PowerShell classes, so if you’re still running WMF4.0, you won’t be able to use class-based DSC resources.  If you’re familiar with object-oriented programming and the concept of classes, class-based resources may be easier for you to develop than function-based ones.  In addition, it’s easier to read and understand a class-based resource.

A function-based module uses input parameters to pass information and functions for the code execution.  The class-based resource instantiates an instance of the class (also known as an object) that is defined by its parameters and uses methods against that class instance to execute the code.  You can find more information about PowerShell classes here.

This example will demonstrate a class-based resource that sets a simple network share named “SMBShareClass”.  The entire code is below, and I’ll walk through each section.

Class-Based DSC Resource Properties

The [DSCResource()] keyword designates that the class is a DSC resource.  The Class keyword defines the class.  In the example, the resource contains 3 properties, and I need to use the DSCProperty keyword and another keyword where necessary to define the type of property (Key, Mandatory, or NotConfigurable).  In the example, I have a key property called Name and two mandatory properties, Path and Ensure.

Notice that the property type is a property type “Ensure” for the Ensure property.  With classes, I can use an Enum type, which is used to define a set of pre-defined constants. The constant values are either Present or Absent. I’ll add an Enum declaration that contains these values, but it must be located before the class declaration.

Syntax Differences

There are two other noteworthy constructs used in class-based resources.  When the class-based DSC resource is called, it instantiates an object with the properties of the class, and the properties contain the settings that you want to be set.  The $this keyword is a reference to the currently instantiated object. If the Get-SMBShare PowerShell cmdlet was part of the class resource, it would look like:

The second is the :: construct.  This is used to call a static method.  I am using it in this example for comparison against one of the constant Ensure values.

The get(), set(), and test() methods are functionally the same as get-TargetResource, set-TargetResource, and test-TargetResource in a function-based resource. Test() determines whether the system is in compliance with the desired settings, and returns True or False based on the system’s setting.  Set() sets the desired state if the system is not already in desired state. Get() returns an instance of SMBShareClass, the instance will contain the current values set on the system.

Module Manifest and Using the Resource

Once written, save the class-based DSC resource to a folder in the module path (typically %systemdrive%\Program Files\WindowsPowerShell\Modules) as a .psd1 file, in a subfolder named the same as the class (SMBShareClass). If you are planning to deploy from a pull server or wish to version the module, you may want to include a version folder (e.g.,  …\Modules\\SMBShareClass).  Finally, create a module manifest with the -DSCResourcesToExport parameter included.

Now the class-based DSC resource is ready to be used in a DSC configuration.  To use it, it still needs to be imported just like a function-based resource using Import-DSCResource.

Pull Server Packaging for Versioning

Packaging a class-based DSC resource for use on a pull server is similar to packaging for a function-based resource.  Using compress-archive, compress everything below the version folder into a file.

After zipping the resource, use new-DSCChecksum to create a new checksum file for the resource, and then copy both the Zip file and the checksum to the pull server’s resource repository folder.

You Have the Tools

Using class-based DSC resources is a great way to create custom resources without some of the packaging overhead of the function-based resource.  In addition, class-based DSC resources also look cleaner and more professional-looking. If you’re already familiar with how classes work, you now have the syntax needed to create these resources. However, if this was all new to you, you now have an overview of how class-based resources work and enough information to create your own.  Happy coding!

Related Topics:

  • PowerShell
  • Uncategorized

    Don't have a login but want to join the conversation? Sign up for a Petri Account