Powershell. Create a class file to hold Custom Objects?

You could use a function as a faux constructor for your custom objects. You wouldn't ever have to duplicate your code, and you could use flags to set your properties right from the function call. Here's an example:

Function New-Constructor
{
    param
    (
        [string]$Name,
        [DateTime]$TimeStamp = (Get-Date)
    )

    $server = New-Object -TypeName PSObject
    $server | Add-Member -MemberType NoteProperty -Name Server -Value $Name
    $server | Add-Member -MemberType NoteProperty -Name TimeStamp -Value $TimeStamp

    # Calling "server" below outputs it, acting as a "return" value
    $server
}

And some sample output:

PS C:\> New-Constructor -Name "MyServer"

Server                                                      TimeStamp
------                                                      ---------
MyServer                                                    9/9/2013 3:27:47 PM


PS C:\> $myServer = New-Constructor -Name "MyServer"
PS C:\> $myServer

Server                                                      TimeStamp
------                                                      ---------
MyServer                                                    9/9/2013 3:27:57 PM


PS C:\> $newServer = New-Constructor -Name "NS" -TimeStamp (Get-Date).AddDays(-1)
PS C:\> $newServer

Server                                                      TimeStamp
------                                                      ---------
NS                                                          9/8/2013 3:33:00 PM

You can do a whole ton of stuff with functions that is out of the scope of this question. Instead, check out about_functions_advanced.

Another option.

Properties

You can replace the '$null' value of the property message to have an initial value. The Prop object is a hashtable of keys (properties) and values (initial values).

$messageClass = New-Object -TypeName PSObject -Prop @{ message = $null; }

Methods

$messageClass | Add-Member -MemberType ScriptMethod -Name "ShowMessage" -Value {

    Try
    {
        Write-Host $this.message    
    }
    Catch
    {
        Throw $_.Exception
    }
}

Constructors

The code below describes a constructor. Polymorphism is achieved using [Parameter(Mandatory=$false)] to assert or not the provision of the specified parameter.

function MessageClass {
    param([Parameter(Mandatory=$true)]
          [String]$mandatoryMessage,
          [Parameter(Mandatory=$false)]
          [String]$optionalMessage)

    $messageObj = $messageClass.psobject.copy()

    if ($optionalMessage)
    {
        $messageObj.message = "$mandatoryMessage $optionalMessage!"
    }
    else
    {
        $messageObj.message = "$mandatoryMessage!"
    }

    $messageObj
}

The constructor can then be called like this:

$var1 = 'Hello'
$var2 = 'World'
$example1 = MessageClass -mandatoryMessage $var1
$example2 = MessageClass -mandatoryMessage $var1 -optionalMessage $var2

To show the text:

$example1.ShowMessage()
$example2.ShowMessage()

The results would be:

Hello!

Hello World!

For best performance I would do it like that:

Add-Type -TypeDefinition '
public class recordEntry {
    public string server;
    public System.DateTime timestamp;
    public int minutes;

    public recordEntry(string _server, System.DateTime _timestamp, int _minutes) {
        server = _server;
        timestamp = _timestamp;
        minutes = _minutes;
    }
}'

$record = [System.Collections.ArrayList]@()
$record = foreach ($j in 0..10){
    [recordEntry]::new("Server1", [datetime]::Now, $j)
}
$record | export-csv -path c:\record.csv -NoTypeInformation

With powershell 5 and later, you can do that in a more modern way:

class Record {
    [string]$Server
    [string]$Timestamp
    [string]$Minutes

    Record([string]$server, 
           [string]$timestamp, 
           [string]$minutes) {
        $this.Server = $server
        $this.Timestamp = $timestamp
        $this.Minutes = $minutes
    }
}

$server1 = [Record]::new("a", "b", "c")
$server2 = [Record]::new("a", "b", "c")
$server3 = [Record]::new("a", "b", "c")

Note that the constructor is optional, so you could also wire your servers with:

$server1 = [Record]::new()
$server1.Server = "a"
$server1.Timestamp = "b"
$server1.Minutes = "c"

Reference: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_classes?view=powershell-7.3#syntax