How can I enable verbose output for class methods in PowerShell?

It's also worth noting that you can keep the verbosity state local to the method by using a hidden method to set `$VerbosePreference`. Check this structure:

```powershell
class ClassName {
hidden [void] _MethodName([string]$text, [System.Management.Automation.ActionPreference]$Verbose) {
$VerbosePreference = $Verbose
Write-Host $text
Write-Verbose $text
}

[void]MethodName([string]$text, [System.Management.Automation.ActionPreference]$Verbose = [System.Management.Automation.ActionPreference]::SilentlyContinue) {
$this._MethodName($text, $Verbose)
}
}
```
This approach allows you to set up your method according to how you want the verbosity control to behave without it leaking outside.

One method you could try is to create a class variable for verbosity within your class, along with a parameter for each method that lets you control verbosity per call. This way, you have a global verbosity control as well as local control for specific methods. For example, you could structure it like this:

```powershell
class MyClass {
[Boolean]$Verbose
MyClass() { $this.Verbose = $false }

[Void] MyMethod([String]$txt, [Boolean]$Verbose) {
if ($Verbose -or $this.Verbose) {
Write-Verbose "Inside MyMethod" -Verbose
}
Write-Host $txt
}
}

$myObj = [MyClass]::New()
$myObj.MyMethod("Test1", $false)
$myObj.MyMethod("Test2", $true)
$myObj.Verbose = $true;
$myObj.MyMethod("Test1", $false)
```
This would allow you to control verbosity on a per-method basis while still having class-wide settings.

If you're specifically targeting class methods but require verbosity, it might be hard to achieve that native style outside of a function context. Perhaps consider restructuring your class code or using decorators to wrap your methods in verbosity panelling.

You might want to consider using a function instead, as functions naturally support verbosity. If you call your class methods from a function, the current verbosity setting should apply within the scope of that function. Just be clear about how your methods are being called to set expectations about verbosity. Here's a simple illustration:

```powershell
function Test-Method {
[ClassName]$obj = [ClassName]::new()
$obj.MethodName('Sample String') # calls without verbose output
}
```