CType.ps1


# CODEWORK Need better parameter validation

[Hashtable]$CType_AddedTypes = @{}

Write-Verbose 'CType.ps1: adding CType base types'
Add-Type -ReferencedAssemblies System.Data -TypeDefinition @'
namespace CType
{
    public class TypeElement
    {
    }
    public class Property : TypeElement
    {
        public string PropertyName;
        public string PropertyType;
        public string PropertyTableWidth;
        public string[] PropertyKeywords;
    }
    public class Parent : TypeElement
    {
        public string ParentTypeName;
    }
    public class Using : TypeElement
    {
        public string Namespace;
    }
    public class ReferencedAssembly : TypeElement
    {
        public string AssemblyName;
    }
    public class SqlWrapper : TypeElement
    {
    }
    public class SqlTemplateObject : TypeElement
    {
        public System.Data.DataRow DataRow;
    }
    public class NoFormatData : TypeElement
    {
    }
}
'@

function Add-CType
{
<#
.SYNOPSIS
Add a locally-defined type to this runspace.

.DESCRIPTION
Add a locally-defined type to this runspace, and optionally define table formatting for the type.
These types can be used as parameter types and in OutputType([typename]) declarations.

.PARAMETER TypeName
Name for the new type. You can include the namespace here or else specify it separately.

.PARAMETER Namespace
Namespace containing the new type. If not specified, the namespace is extracted from TypeName.

.PARAMETER ParentTypeName
Parent class of the new class, default is System.Object

.PARAMETER Using
Other namespaces, typically those containing types specified in PropertyType

.PARAMETER ReferencedAssemblies
Other assemblies, typically those containing types specified in PropertyType

.PARAMETER SqlWrapper
Make the new type a SQL wrapper class for use in ConvertTo-CTypeSqlWrapper.
This is set automatically if any PropertyKeyword contains SQLWrapper,
or if SQLTemplateObject is set.

.PARAMETER SqlTemplateObject
If specified, include all properties of this SQL template object in the SQL wrapper class.
Properties already specified in PropertyName are not affected.
SqlWrapper is automatically set if this is specified.

.PARAMETER NoFormatData
Skip defining formatting metadata for this type.
For example, you might want to combine all the formatting for the types in your module
into a single file.

.PARAMETER PropertyName
Name of a property of the type being defined

.PARAMETER PropertyType
Type of a property of the type being defined

.PARAMETER PropertyTableWidth
Table width in characters of a property of the type being defined.
If one or more properties specify PropertyTableWidth, a formatting directive
will be generated for this type and entered into the runspace.
If not specified, this property is not in the default table format.
This can also be set to '*', in which case this property is displayed at full width;
this should generally only be used for the last property with defined PropertyTableWidth.

.PARAMETER PropertyKeywords
Other keywords. The only keywords currently implemented are "Trim"
which trims leading/trailing whitespace from the output string in the table formatting,
and "SQLWrapper" which designates a read-only property read from the wrapped SQL object.

.EXAMPLE
# Define a new type
PS> @"
PropertyName,PropertyType,PropertyTableWidth,PropertyKeywords
PrimaryTarget,string,25,Trim
SecondaryTarget,string,25,Trim
Weight,int,10
IsPrimary,Boolean,10
Description,String,*
MainConnection,SqlConnection
SecondaryConnection,SqlConnection
"@ | ConvertFrom-Csv | Add-CType -TypeName MyType `
                                 -Namespace MyCompany.Namespace `
                                 -Using System.Data.SqlClient `
                                 -ReferencedAssemblies System.Data

# You can now use this as a full-fledged type, for example define parameters as
# param( [MyCompany.Namespace.MyType]$MyParameter )

# Create an instance of the type
PS> New-Object -TypeName MyCompany.Namespace.MyType -Property @{
    PrimaryTarget = "String1";
    SecondaryTarget = "String2";
    Weight = 4;
    Description = "This is a very long description"
    }

PrimaryTarget             SecondaryTarget           Weight     IsPrimary  Description                                                                                                                
-------------             ---------------           ------     ---------  -----------                                                                                                                
String1                   String2                   4          False      This is a very long description                                                                                            

.EXAMPLE
# Define a new CType Class
ConvertFrom-Csv @'
PropertyType,PropertyName,PropertyTableWidth,PropertyKeywords
string,Name,20
string,HostName,20
DateTime,WhenCreated,25
DateTime,WhenDeleted,25
'@ | Add-CType -TypeName MyCompany.MyNamespace.MyClass
# Create wrapped object
New-Object -Type MyCompany.MyNamespace.MyClass -Property @{
    Name = "MyName"
    WhenCreated = (get-date)
}

.EXAMPLE
# Define a new SQL Wrapper Class
ConvertFrom-Csv @'
PropertyType,PropertyName,PropertyTableWidth,PropertyKeywords
string,Name,20,SQLWrapper
string,HostName,20,SQLWrapper
DateTime,WhenCreated,25,SQLWrapper
DateTime,WhenDeleted,25,SQLWrapper
'@ | Add-CType -TypeName MyCompany.MyNamespace.MyClass -SqlWrapper
# Create wrapped objects
$SqlWrappedObjects = $SqlDataRows | ConvertTo-CTypeSqlWrapper -TypeName MyCompany.MyNamespace.MyClass

.NOTES
This method should only be called once for any class. Calling a second time
is generally harmless as long as the type definition is identical,
otherwise an error will be reported. Types cannot be altered once added to
a process (AppDomain?).

.LINK
ConvertTo-CTypeSqlWrapper
Add-Type
Update-CTypeFormatData
Update-FormatData
#>
    [CmdletBinding()]
    param(
        [string][parameter(Mandatory=$true)]$TypeName,
        [string]$Namespace,
        [string]$ParentTypeName,
        [string[]]$Using,
        [string[]]$ReferencedAssemblies,
        [switch]$SqlWrapper,
        [System.Data.DataRow]$SqlTemplateObject,
        [switch]$NoFormatData,
        [string][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyName,
        [string][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyType,
        [string][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyTableWidth,
        [string[]][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyKeywords
        )
    begin
    {
Write-Verbose -Message @"
$($MyInvocation.InvocationName): TypeName $TypeName
$($MyInvocation.InvocationName): Namespace $Namespace
$($MyInvocation.InvocationName): ParentTypeName $ParentTypeName
$($MyInvocation.InvocationName): Using $Using
$($MyInvocation.InvocationName): ReferencedAssemblies $ReferencedAssemblies
$($MyInvocation.InvocationName): SqlWrapper $SqlWrapper
$($MyInvocation.InvocationName): SqlTemplateObject $SqlTemplateObject
"@
        if (-not $Namespace)
        {
            $nameComponents = $TypeName.Split('.')
            if ($nameComponents.Count -lt 2)
            {
                throw 'You must specify a Namespace or else a TypeName which contains a Namespace'
            }
            $TypeName = $nameComponents[-1]
            $Namespace = $nameComponents[0..($nameComponents.Count - 2)] -join '.'
        }
        if ($CType_AddedTypes["$Namespace.$TypeName"])
        {
            Write-Warning "$($MyInvocation.InvocationName): Class $Namespace.$TypeName was already added; trying anyhow"
        }
        if ($SqlTemplateObject)
        {
            $SqlWrapper = $true
        }
        $propertyList = @()
    }
    process
    {
        if ($PropertyName)
        {
Write-Verbose -Message @"
$($MyInvocation.InvocationName): PropertyName $PropertyName
$($MyInvocation.InvocationName): PropertyType $PropertyType
$($MyInvocation.InvocationName): PropertyTableWidth $PropertyTableWidth
$($MyInvocation.InvocationName): PropertyKeywords $PropertyKeywords
"@
            if (-not $PropertyType)
            {
                throw 'PropertyType must be specified for all properties'
            }
            if ($PropertyTableWidth)
            {
                if ($PropertyTableWidth -ne '*')
                {
                    $w = $PropertyTableWidth -as [int]
                    if ($w -lt 1)
                    {
                        throw "PropertyTableWidth must be either a positive integer or '*' if it is specified"
                    }
                }
            }
            $propertyList += New-Object -TypeName CType.Property -Property @{
                PropertyName = $PropertyName
                PropertyType = $PropertyType
                PropertyTableWidth = $PropertyTableWidth
                PropertyKeywords = $PropertyKeywords
                }
            if ('SQLWrapper' -in $PropertyKeywords)
            {
                $SqlWrapper = $true
            }
        }
    }
    end
    {
        if ($SqlTemplateObject)
        {
            Write-Verbose "$($MyInvocation.InvocationName): SqlTemplateObject specified, adding additional properties"
            foreach ($column in $SqlTemplateObject.Table.Columns)
            {
                $name = $column.ColumnName
                $type = $column.DataType
                if ($name -in $propertyList.PropertyName)
                {
                    Write-Verbose "$($MyInvocation.InvocationName): SqlTemplateObject column $type $name already in property list"            
                }
                else
                {
                    Write-Verbose "$($MyInvocation.InvocationName): SqlTemplateObject column $type $name must be added property list"            
                    $propertyList += New-Object -TypeName CType.Property -Property @{
                        PropertyName = $name;
                        PropertyType = $type;
                        PropertyTableWidth = 0;
                        PropertyKeywords = @('SQLWrapper');
                        }
                }
            }
            $SqlWrapper = $true
        }

        if ($SqlWrapper)
        {
            if ($Using -notcontains 'System.Data')
            {
                $Using += 'System.Data'
            }
            if ($ReferencedAssemblies -notcontains 'System.Data')
            {
                $ReferencedAssemblies += 'System.Data'
            }
        }

        Write-Verbose "$($MyInvocation.InvocationName): building C# type definition"
        $typeDefinition = New-Object -TypeName System.Text.StringBuilder
        $Using = @("System") + ($Using | Where-Object {$_})
        $Using | % {
            $null = $typeDefinition.AppendLine("using $_;")
            }
$null = $typeDefinition.AppendLine(@"
namespace $Namespace
{
    public class $TypeName $(if ($ParentTypeName) {": $ParentTypeName"})
    {
"@)
    if ($SqlWrapper)
    {
$null = $typeDefinition.AppendLine(@"
        private System.Data.DataRow WrappedSqlObject;

        public $TypeName(System.Data.DataRow obj)
        {
            this.WrappedSqlObject = obj;
        }

"@)
    }
    foreach ($property in $propertyList)
    {
        $name = $property.PropertyName
        $type = $property.PropertyType
        Write-Verbose "$($MyInvocation.InvocationName) Property $type $name"

        # CSharp seems to be picky about spelling and capitalization of these types
        $typeObject = $type -as [Type]
        if ($typeObject.FullName)
        {
            $type = $typeObject.FullName
        }

        $propertyType = $type
        if ('SqlWrapper' -in $property.PropertyKeywords)
        {
            $valueExpression = "($type)val";
            if ($typeObject.IsValueType)
            {
                $propertytype = "Nullable<$type>"
            }

$null = $typeDefinition.AppendLine(@"
        public $propertyType $name
        {
            get {
                object val = this.WrappedSqlObject["$name"];
                if ((val == null) || (val.GetType().FullName == "System.DBNull"))
                {
                    return null;
                }
            return $valueExpression;
            } // get $propertyType $name
        } // property $propertyType $name


"@)
        }
        else # -not $SqlClassWrapper
        {

$null = $typeDefinition.AppendLine(@"
        public $propertyType $name { get; set; }
"@)

        }
    }

$null = $typeDefinition.AppendLine(@"
    }
}
"@)

        Write-Verbose "$($MyInvocation.InvocationName): Adding type:`n$($typeDefinition.ToString())"
        Add-Type -TypeDefinition $typeDefinition.ToString() -ReferencedAssemblies $ReferencedAssemblies

        $CType_AddedTypes["$Namespace.$classname"] = $true

        if (-not $NoFormatData)
        {
            $tableProperties = $propertyList | Where-Object {$_.PropertyTableWidth}
            if ($tableProperties)
            {
                $text = $tableProperties | Get-CTypeFormatPS1XML -TypeName "$Namespace.$TypeName"
                $text | Update-CTypeFormatData -TypeName "$Namespace.$TypeName"
            }
        }
    }
}

function Update-CTypeFormatData
{
<#
.SYNOPSIS
Add the specified formatting metadata to the current runspace.

.PARAMETER TypeName
Full typename for the type including namespace

.PARAMETER FormatDataString
Format data string from Get-CTypeFormatPS1XML

.EXAMPLE
$tableProperties = ConvertFrom-Csv @'
PropertyType,PropertyName,PropertyTableWidth
string,Name,20
string,HostName,20
DateTime,WhenCreated,25
DateTime,WhenDeleted,25
'@
$text = $tableProperties | Get-CTypeFormatPS1XML -TypeName "$Namespace.$TypeName"
Update-CTypeFormatData -TypeName "$Namespace.$TypeName" -FormatDataString $text

.LINK
Get-CTypeFormatPS1XML
Add-CType
Update-FormatData
#>
    [CmdletBinding()]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$TypeName,
        [string][parameter(Mandatory=$true, ValueFromPipeline=$true)]$FormatDataString
        )
    begin
    {
        $activity = "$($MyInvocation.InvocationName) $TypeName"
        $tempfile = Join-Path $env:temp "$TypeName.$(get-date -Format 'yyyyMMdd-hhmmss-fffffff').format.ps1xml"
        [System.Text.StringBuilder]$text = New-Object -TypeName System.Text.StringBuilder
    }
    process
    {
        $null = $text.AppendLine($FormatDataString)
    }
    end
    {
        Write-Verbose "$activity`: Adding format data to temporary file $tempfile from formatting directive:`n$FormatDataString"
        $FormatDataString | Set-Content -Path $tempFile
        try
        {
            Write-Verbose "$activity`: Updating format data"
            Update-FormatData -PrependPath $tempfile
        }
        catch
        {
            if (Test-Path $tempfile -ErrorAction SilentlyContinue)
            {
                Write-Verbose "$activity`: Deleting temporary file $tempfile"
                Remove-Item $tempfile
            }
        }
    }
}

function Get-CTypeFormatPS1XML
{
<#
.SYNOPSIS
Returns the text of a PS1XML which defines output formatting for a type.

.DESCRIPTION
Returns the text of a PS1XML which defines output formatting for a type.
Pass this to Update-CTypeFormatData to apply this formatting to the current session.
You can also save this into a PS1XML file associated with your module.

.PARAMETER TypeName
Name for the type

.PARAMETER PropertyName
Name of a property of the type being defined

.PARAMETER PropertyType
Type of a property of the type being defined

.PARAMETER PropertyTableWidth
Table width of a property of the type being defined, per Add-CType.

.PARAMETER PropertyKeywords
Other keywords per Add-CType.

.LINK
Add-CType
Update-CTypeFormatData
#>
    [OutputType([string])]
    [CmdletBinding()]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$TypeName,
        [string][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyName,
        [string][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyType,
        [string][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyTableWidth,
        [string[]][parameter(ValueFromPipelineByPropertyName=$true)]$PropertyKeywords
        )

    begin
    {
        $activity = "$($MyInvocation.InvocationName) $TypeName"
        Write-Verbose $activity
# You could also build this using the [xml] class
$fileHeader = @"
<?xml version="1.0" encoding="utf-8" ?>
<Configuration>
    <ViewDefinitions>

"@
$templateViewHeader = @"
        <View>
            <Name>{0}</Name>
            <ViewSelectedBy>
                <TypeName>{0}</TypeName>
            </ViewSelectedBy>
            <TableControl>
                <TableHeaders>
"@
$templateColumnHeader = @"
                    <TableColumnHeader>
                        <Label>{0}</Label>
                    </TableColumnHeader>
"@
$templateColumnHeaderWithWidth = @"
                    <TableColumnHeader>
                        <Label>{0}</Label>
                        <Width>{1}</Width>
                    </TableColumnHeader>
"@
$headerItemSeparator = @"
                </TableHeaders>
                <TableRowEntries>
                    <TableRowEntry>
                        <TableColumnItems>
"@
$templateColumnItem = @"
                            <TableColumnItem>
                                <PropertyName>{0}</PropertyName>
                            </TableColumnItem>
"@
$templateColumnItemWithTrim = @"
                            <TableColumnItem>
                                <ScriptBlock>
                                  (Out-String -InputObject `$_.{0}).Trim()
                                </ScriptBlock>
                            </TableColumnItem>
"@
$viewFooter = @"
                        </TableColumnItems>
                    </TableRowEntry>
                 </TableRowEntries>
            </TableControl>
        </View>        
"@
$fileFooter = @"
    </ViewDefinitions>
</Configuration>
"@

        $propertyList = New-Object System.Collections.ArrayList

        $fileContent = New-Object System.Text.StringBuilder -ArgumentList $fileHeader
        $null = $fileContent.AppendLine( ($templateViewHeader -f $TypeName) )
    }

    process
    {
Write-Verbose -Message @"
$activity`: PropertyName $PropertyName
$activity`: PropertyType $PropertyType
$activity`: PropertyTableWidth $PropertyTableWidth
$activity`: PropertyKeywords $PropertyKeywords
"@
        if ($PropertyName -and $PropertyTableWidth)
        {
            if (-not $PropertyType)
            {
                throw 'PropertyType must be specified for all properties'
            }
            if ($PropertyTableWidth)
            {
                if ($PropertyTableWidth -ne '*')
                {
                    $w = $PropertyTableWidth -as [int]
                    if ($w -lt 1)
                    {
                        throw "PropertyTableWidth must be either a positive integer or '*' if it is specified"
                    }
                }
            }
            $obj = New-Object -TypeName CType.Property -Property @{
                PropertyName = $PropertyName
                PropertyType = $PropertyType
                PropertyTableWidth = $PropertyTableWidth
                PropertyKeywords = $PropertyKeywords
                }
            $null = $propertyList.Add($obj)
        }
        else
        {
            Write-Verbose "$activity`: Skipping due to null name or width"
        }
    }

    end
    {
        foreach ($p in $propertyList)
        {
            if ($p.PropertyTableWidth)
            {
                if ($p.PropertyTableWidth -eq '*')
                {
                    $null = $fileContent.AppendLine( ($templateColumnHeader -f $p.PropertyName) )
                }
                else
                {
                    $null = $fileContent.AppendLine( ($templateColumnHeaderWithWidth -f $p.PropertyName,$p.PropertyTableWidth) )
                }
            }
        }
        $null = $fileContent.AppendLine( $headerItemSeparator )
        foreach ($p in $propertyList)
        {
            if ($p.PropertyTableWidth)
            {
                if ('Trim' -in $p.PropertyKeywords)
                {
                    $null = $fileContent.AppendLine( ($templateColumnItemWithTrim -f $p.PropertyName) )
                }
                else
                {
                    $null = $fileContent.AppendLine( ($templateColumnItem -f $p.PropertyName) )
                }
            }
        }
        $null = $fileContent.AppendLine( $viewFooter )
        $null = $fileContent.AppendLine( $fileFooter )

        Write-Output $fileContent.ToString()
    }
}


function ConvertTo-CTypeSqlWrapper
{
<#
.SYNOPSIS
Wraps a SQL row in a wrapper object.
.DESCRIPTION
Wraps a SQL row in a wrapper object. The wrapper class must first be defined by
Add-CType -SqlWrapper. The wrapped object has several advantages over the
raw System.Data.DataRow object:
(1) Property value System.DBNull is automatically converted to $null so that it is boolean-false in scripting
(2) Type can be use in [OutputType([typename])] attributes
(3) Type can be assigned formatting directives and other PowerShell type decorations
(4) All properties are read-only
(5) Hides unneeded properties of base SQL object

.PARAMETER InputObject
System.Data.DataRow object to be wrapped

.PARAMETER TypeName
Name of wrapper class, should be the same as for Add-CType

.PARAMETER AddCType
If specified, the type will be created automatically
the first time an input object of this type is received,
where the first object is a template.

.PARAMETER AddCTypeScriptBlock
If specified, the type will be created automatically
the first time an input object of this type is received,
where the first object is a template and this script block
defines additional properties of the type. This implies -AddCType.
Note the limitations in Notes below.

.EXAMPLE
$connection = New-Object System.Data.SqlClient.SqlConnection $connectionString
$command = New-Object System.Data.SqlClient.SqlCommand $commandString,$connection
$adapter = New-Object System.Data.SqlClient.SqlDataAdapter $command
$dataset = New-Object System.Data.DataSet
$null = $adapter.Fill($dataSet)
$result = $tables[0].Rows
$wrappedResult = $result | ConvertTo-CTypeSqlWrapper -TypeName MyCompany.MyNamespace.MyWrapperClass

.NOTES
Note that the type will be defined based on the first InputObject encountered.
Even if subsequent objects have a different property list, the type cannot be changed.

Note that you can define a type using AddCTypeScriptBlock, but because that type
cannot be defined until the first template object is created, you may have difficulty
using the type in an OutputType([typename]) block or a parameter definition.
Consider generating the type definition with ConvertTo-CTypeDefinition
and pasting the CType definition directly into your code.

.LINK
Add-CType
CType
ConvertTo-CTypeSqlDefinition
#>
    [CmdletBinding()]
    param(
        [parameter(ValueFromPipeline=$true)][System.Data.DataRow]$InputObject,
        [parameter(Mandatory=$true,Position=0)][string]$TypeName,
        [switch]$AddCType,
        [ScriptBlock[]][parameter(Position=1)]$AddCTypeScriptBlock
    )
    process
    {
        if ($AddCType -or $AddCTypeScriptBlock)
        {
            if (-not $CType_AddedTypes[$TypeName])
            {
                CType -TypeName $TypeName -TypeElement $AddCTypeScriptBlock,(SqlTemplateObject $InputObject)
            }
        }
        New-Object -TypeName $TypeName -ArgumentList $InputObject
    }
}

function CType
{
<#
.SYNOPSIS
Create a new type
.PARAMETER TypeName
Name of the new type. Include namespace e.g. "MyCompany.MyNamespace.MyClassName"
.PARAMETER TypeElement
One or more script blocks or type elements which define class properties and other elements of the class.
The type elements may only contain objects on the list
property, sqlproperty, parent, use, ref,SqlWrapper, SqlTemplateObject, and NoFormatData,
and the script blocks must evaluate to objects of those types.
The script block definition must begin on the same line as the CType invocation,
or must be linked with backtick.
.EXAMPLE
# Creates a type with 4 properties, three of which are displayed in the default formatter.
CType MyCompany.MyNamespace.MyClassName {
  parent MyCompany.MyNamespace.MyParentClass
  property string PropertyName1 -PropertyTableWidth 20 -PropertyKeywords trim
  if ($true)
  {
    property int PropertyName2  -PropertyTableWidth 15
  }
  property string PropertyName3 -PropertyTableWidth *
  property bool PropertyName4
}
.EXAMPLE
# Creates a type with 4 properties, three SQL wrappers and one non-wrapped property.
# The non-wrapped property can be set like any other read/write property, the others
# always read from the equivalent property of the wrapped DataRow object.
CType MyCompany.MyNamespace.MyClassName {
  parent MyCompany.MyNamespace.MyParentClass
  sqlproperty string PropertyName1 -PropertyTableWidth 20 -PropertyKeywords trim
  sqlproperty int PropertyName2  -PropertyTableWidth 15
  property string PropertyName3 -PropertyTableWidth *
  sqlproperty bool PropertyName4
}
.NOTES
A type with a given name can only be defined once per PowerShell runspace.
If you need to change it you will need to exit the runspace where it is defined.
.LINK
Add-CType
#>
    [CmdletBinding()]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$TypeName,
        [parameter(Position=1)]$TypeElement
        )
    $typeElements = foreach ($element in $TypeElement)
    {
        if ($element)
        {
            if ($element -is [ScriptBlock])
            {
                Invoke-Command -ScriptBlock $element
            }
            elseif ($element -is [ScriptBlock[]])
            {
                $element | % {Invoke-Command -ScriptBlock $_}
            }
            else
            {
                $element
            }
        }
    }
    foreach ($element in $typeElements)
    {
        if (-not ($element -is [CType.TypeElement]))
        {
            throw "$($MyInvocation.InvocationName): Invalid TypeElement $($element.GetType().FullName): TypeElement may only contain property, parent, use, ref,SqlWrapper, SqlTemplateObject, and NoFormatData, or script blocks generate them"
        }
    }
    [CType.Property[]]$properties = $typeElements | Where-Object {$_ -is [CType.Property]}
    [string[]]$parentTypes = $typeElements | Where-Object {$_ -is [CType.Parent]} | Select-Object -ExpandProperty ParentTypeName
    [string[]]$using = $typeElements | Where-Object {$_ -is [CType.Using]} | Select-Object -ExpandProperty Namespace
    [string[]]$referencedAssemblies = $typeElements | Where-Object {$_ -is [CType.ReferencedAssembly]} | Select-Object -ExpandProperty AssemblyName
    [System.Data.DataRow]$sqlTemplateObject = $null
    [System.Data.DataRow[]]$sqlTemplateObjects = @($typeElements | Where-Object {$_ -is [CType.SqlTemplateObject]} | Select-Object -ExpandProperty DataRow)
    if ($parentTypes)
    {
        if ($parentTypes.Count -gt 1)
        {
            throw 'You may only specify one parent type'
        }
        $parentType = $parentTypes[0]
    }
    else
    {
        $parentType = $null
    }
    if ($sqlTemplateObjects)
    {
        if ($sqlTemplateObjects.Count -gt 1)
        {
            throw 'You may only specify one SqlTemplateObject'
        }
        $sqlTemplateObject = $sqlTemplateObjects[0]
    }
    else
    {
        $sqlTemplateObject = $null
    }
    [bool]$noFormatData = [bool]($typeElements | Where-Object {$_ -is [CType.NoFormatData]} )
    [bool]$sqlWrapper = [bool]($typeElements | Where-Object {$_ -is [CType.SqlWrapper]} )
    $split = $TypeName.Split('.')
    if ($split.Count -lt 2)
    {
        throw 'You must specify full classname including namespace'
    }
    $classname = $split[-1]
    $namespace = $split[0..($split.Count-2)] -join '.'

    $properties | Add-CType -TypeName $TypeName `
                            -ParentTypeName $parentType `
                            -Using $using `
                            -ReferencedAssemblies $referencedAssemblies `
                            -SqlWrapper:$sqlWrapper `
                            -SqlTemplateObject $SqlTemplateObject `
                            -NoFormatData:$NoFormatData
}

function property
{
<#
.SYNOPSIS
Define a property for use in CType
#>
    [CmdletBinding()]
    [OutputType([CType.Property])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$PropertyType,
        [string][parameter(Mandatory=$true,Position=1)]$PropertyName,
        [string]$width,
        [switch]$trim
        )
    $propertyHash = @{
        PropertyType=$PropertyType
        PropertyName=$PropertyName
        }
    if ($width)
    {
        $propertyHash['PropertyTableWidth'] = $width
    }
    if ($trim)
    {
        $propertyHash['PropertyKeywords'] = "Trim"
    }
    New-Object -TypeName CType.Property -Property $propertyHash
}

function sqlproperty
{
<#
.SYNOPSIS
Define a SQL wrapper property for use in CType
#>
    [CmdletBinding()]
    [OutputType([CType.Property])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$PropertyType,
        [string][parameter(Mandatory=$true,Position=1)]$PropertyName,
        [string]$width,
        [switch]$trim
        )
    $propertyHash = @{
        PropertyType=$PropertyType
        PropertyName=$PropertyName
        }
    if ($width)
    {
        $propertyHash['PropertyTableWidth'] = $width
    }
    if ($trim)
    {
        $propertyHash['PropertyKeywords'] = ('SQLWrapper','Trim')
    }
    else
    {
        $propertyHash['PropertyKeywords'] = 'SQLWrapper'
    }
    New-Object -TypeName CType.Property -Property $propertyHash
}

function parent
{
<#
.SYNOPSIS
Specify a parent class for use in CType
#>
    [CmdletBinding()]
    [OutputType([CType.Parent])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$ParentTypeName
        )
    New-Object -TypeName CType.ParentType -Property @{
        ParentTypeName=$ParentTypeName
        }
}

function use
{
<#
.SYNOPSIS
Specify a Using reference for use in CType
#>
    [CmdletBinding()]
    [OutputType([CType.Using])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$Namespace
        )
    New-Object -TypeName CType.Using -Property @{
        Namespace=$Namespace
        }
}

function ref
{
<#
.SYNOPSIS
Specify a Referenced Assembly for use in CType
#>
    [CmdletBinding()]
    [OutputType([CType.ReferencedAssembly])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$AssemblyName
        )
    New-Object -TypeName CType.ReferencedAssembly -Property @{
        AssemblyName=$AssemblyName
        }
}

function SqlWrapper
{
<#
.SYNOPSIS
Specify that a CType should be a SQL Wrapper
.LINK
ConvertTo-CTypeSqlWrapper
#>
    [CmdletBinding()]
    [OutputType([CType.SqlWrapper])]
    param(
        )
    New-Object -TypeName CType.SqlWrapper
}

function SqlTemplateObject
{
<#
.SYNOPSIS
Specify a SQL template object for use in CType
#>
    [CmdletBinding()]
    [OutputType([CType.ReferencedAssembly])]
    param(
        [System.Data.DataRow][parameter(Mandatory=$true,Position=0)]$SqlTemplateObject
        )
    New-Object -TypeName CType.SqlTemplateObject -Property @{
        DataRow=$SqlTemplateObject
        }
}

function NoFormatData
{
<#
.SYNOPSIS
Specify that a CType should not generate formatting data
.DESCRIPTION
Specify that a CType should not generate formatting data.
For example, you might perfer to generate the formatting data using
Get-CTypeFormatPS1XML and enter this into the PS1XML for your module.
#>
    [CmdletBinding()]
    [OutputType([CType.NoFormatData])]
    param(
        )
    New-Object -TypeName CType.NoFormatData
}

function ConvertTo-CTypeDefinition
{
<#
.SYNOPSIS
Generate a string representing a CType definition for the specified SQL object
.DESCRIPTION
Generate a string representing a CType definition for the specified SQL object.
You can paste this string into your module code to generate a CType SQL wrapper
for objects of the specified class, reordering the properties and adding
width and keywords to specify the formatting for the type.
.LINK
CType
Add-CType
ConvertTo-CTypeSqlWrapper
#>
    [CmdletBinding()]
    [OutputType([string])]
    param(
        [System.Data.DataRow][parameter(Mandatory=$true,Position=0,ValueFromPipeline=$true)]$SqlTemplateObject
        )
    process
    {
[System.Text.StringBuilder]$typeDefinition = New-Object -TypeName System.Text.StringBuilder -ArgumentList @"
CType YourClassNameHere {
    SqlWrapper
    parent YourParentClassHere

"@
        foreach ($column in $SqlTemplateObject.Table.Columns)
        {
            $name = $column.ColumnName
            $type = $column.DataType
            $null = $typeDefinition.AppendLine("    sqlproperty $type $name")
        }
        $null = $typeDefinition.AppendLine('}')
        $typeDefinition.ToString()
    }
}

function Test-CTypeIsDefined
{
<#
.SYNOPSIS
Test whether a CType type is already defined.
.DESCRIPTION
Test whether a CType type is already defined.
Note that types may not be removed from a PowerShell session once defined.
.PARAMETER TypeName
Name for the type.
.EXAMPLE
if (-not (Test-CTypeIsDefined MyCompany.MyNamespace.ClassName))
{
    CType MyCompany.MyNamespace.ClassName2 {
        CTypeProperty int Property1
        CTypeProperty string Property2
        CTypeProperty boolean Property3
    }
}
.NOTES
This method is fast, but it only detects CType types, not .NET types generally.
.LINK
CType
Add-CType
#>
    [CmdletBinding()]
    [OutputType([bool])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$TypeName
        )
    return [bool]($CType_AddedTypes[$TypeName])
}

function Test-CTypeDotNetTypeIsDefined
{
<#
.SYNOPSIS
Test whether a type is already defined.
.DESCRIPTION
Test whether a type is already defined.
Note that types may not be removed from a PowerShell session once defined.
.PARAMETER TypeName
Name for the type.
.EXAMPLE
if (-not (Test-CTypeDotNetTypeIsDefined MyCompany.MyNamespace.ClassName))
{
    CType MyCompany.MyNamespace.ClassName2 {
        CTypeProperty int Property1
        CTypeProperty string Property2
        CTypeProperty boolean Property3
    }
}
.NOTES
This method uses .NET reflection to search for the type, so it can take 100-200ms to run.
Use it sparingly. Consider using Test-CTypeIsDefined instead.
.LINK
CType
Add-CType
#>
    [CmdletBinding()]
    [OutputType([bool])]
    param(
        [string][parameter(Mandatory=$true,Position=0)]$TypeName
        )
    $time = Measure-Command {
        $val = [bool]([appdomain]::CurrentDomain.GetAssemblies() | Where-Object DefinedTypes | Where-Object {$_.DefinedTypes.FullName -eq $TypeName})
    }
    Write-Verbose "$($MyInvocation.InvocationName): Searching for type $TypeName took $($time.TotalMilliseconds) milliseconds"
    $val
}