mirror of
https://github.com/Micke-K/IntuneManagement.git
synced 2026-09-28 19:05:38 +02:00
641 lines
25 KiB
C#
641 lines
25 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Avalonia;
|
|
using Avalonia.Controls;
|
|
using Avalonia.Controls.ApplicationLifetimes;
|
|
using Avalonia.Data.Converters;
|
|
using Avalonia.Markup.Xaml;
|
|
using Avalonia.Markup.Xaml.Styling;
|
|
using Avalonia.Platform.Storage;
|
|
using Avalonia.Themes.Fluent;
|
|
using Avalonia.Threading;
|
|
|
|
namespace IntuneManagement.AvaloniaHost;
|
|
|
|
public sealed class IntuneManagementApp : Application
|
|
{
|
|
public static string ThemeVariant { get; set; } = "Default";
|
|
|
|
public override void Initialize()
|
|
{
|
|
Styles.Add(new FluentTheme());
|
|
|
|
// DataGrid ships in a separate package with its own theme XAML. Add
|
|
// the StyleInclude here so DataGrid controls render with Fluent
|
|
// styling instead of as unstyled placeholders. Wrapped in try/catch
|
|
// so a missing Avalonia.Controls.DataGrid.dll (e.g. older restore)
|
|
// doesn't kill app startup — DataGrid just won't be usable.
|
|
try
|
|
{
|
|
var dgStylesUri = new Uri("avares://Avalonia.Controls.DataGrid/Themes/Fluent.xaml");
|
|
Styles.Add(new StyleInclude(dgStylesUri) { Source = dgStylesUri });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Diagnostics.Trace.WriteLine("DataGrid theme include failed: " + ex.Message);
|
|
}
|
|
|
|
RequestedThemeVariant = string.Equals(ThemeVariant, "Dark", StringComparison.OrdinalIgnoreCase)
|
|
? Avalonia.Styling.ThemeVariant.Dark
|
|
: Avalonia.Styling.ThemeVariant.Light;
|
|
}
|
|
}
|
|
|
|
// AvaloniaHost: PowerShell-driven Avalonia host running on the calling thread.
|
|
//
|
|
// Model: Setup runs on the PowerShell thread. That thread becomes Avalonia's
|
|
// UI thread. RunMainWindow blocks running the dispatcher loop until the last
|
|
// window closes. Because PS thread == UI thread, no cross-thread marshaling
|
|
// is needed for UI work, and PowerShell scriptblocks attached to events fire
|
|
// on the same thread that subscribed them — exactly like WPF in PowerShell.
|
|
public static class Host
|
|
{
|
|
private static ClassicDesktopStyleApplicationLifetime _lifetime;
|
|
private static bool _setup;
|
|
private static readonly object _gate = new();
|
|
private static string[] _droppedAssemblies;
|
|
|
|
[DllImport("/usr/lib/libSystem.B.dylib")]
|
|
private static extern int pthread_main_np();
|
|
|
|
public static void Initialize(string themeVariant = "Default")
|
|
{
|
|
if (OperatingSystem.IsMacOS() && pthread_main_np() == 0)
|
|
throw new InvalidOperationException(
|
|
"Avalonia on macOS requires the process main thread. Launch with Start-Avalonia.command.");
|
|
lock (_gate)
|
|
{
|
|
if (_setup) return;
|
|
IntuneManagementApp.ThemeVariant = themeVariant ?? "Default";
|
|
|
|
_lifetime = new ClassicDesktopStyleApplicationLifetime
|
|
{
|
|
Args = Array.Empty<string>(),
|
|
ShutdownMode = ShutdownMode.OnLastWindowClose
|
|
};
|
|
|
|
AppBuilder.Configure<IntuneManagementApp>()
|
|
.UsePlatformDetect()
|
|
.WithInterFont()
|
|
.LogToTrace()
|
|
.SetupWithLifetime(_lifetime);
|
|
|
|
SanitizeXamlTypeSystem();
|
|
|
|
_setup = true;
|
|
}
|
|
}
|
|
|
|
// Avalonia's runtime XAML loader resolves types by walking every assembly in
|
|
// the AppDomain and calling GetExportedTypes() on each. That call throws for
|
|
// an assembly whose type references cannot be resolved, and the exception
|
|
// propagates out of the loader, so a single unreadable assembly stops every
|
|
// XAML file in the app from parsing.
|
|
//
|
|
// On Windows, PowerShell's assembly resolver answers some requests out of the
|
|
// .NET Framework GAC (System.Web.Extensions v4.0 is loaded during pwsh
|
|
// startup). Those assemblies reference .NET Framework types that do not exist
|
|
// on modern .NET - System.Web ships as a facade with no types at all - so
|
|
// enumerating them throws TypeLoadException. Office interop assemblies, which
|
|
// the documentation subsystem loads for Word output, fail the same way.
|
|
//
|
|
// Drop those assemblies from the loader's type system before the first parse.
|
|
// The XAML in this app only references Avalonia and our own types, so nothing
|
|
// that can be dropped here was ever reachable from markup. On Linux and macOS
|
|
// no such assembly is loaded and this is a no-op.
|
|
//
|
|
// Returns the names of the assemblies that were dropped. Reflection is used
|
|
// against internal Avalonia members, so every failure path degrades to
|
|
// "changed nothing" rather than breaking startup.
|
|
public static string[] SanitizeXamlTypeSystem()
|
|
{
|
|
if (_droppedAssemblies != null) return _droppedAssemblies;
|
|
|
|
const BindingFlags Flags = BindingFlags.Public | BindingFlags.NonPublic |
|
|
BindingFlags.Static | BindingFlags.Instance;
|
|
var dropped = new List<string>();
|
|
try
|
|
{
|
|
var loaderAsm = typeof(AvaloniaRuntimeXamlLoader).Assembly;
|
|
var compiler = loaderAsm.GetType("Avalonia.Markup.Xaml.XamlIl.AvaloniaXamlIlRuntimeCompiler");
|
|
var initSre = compiler?.GetMethod("InitializeSre", Flags);
|
|
var tsField = compiler?.GetField("_sreTypeSystem", Flags);
|
|
if (initSre == null || tsField == null) return _droppedAssemblies = Array.Empty<string>();
|
|
|
|
// Build the type system so it can be inspected before it is used.
|
|
// This same walk is what fails, but the type system field is assigned
|
|
// before the failing step, so the object is available afterwards
|
|
// either way - the throw is expected here and is not an error.
|
|
try { initSre.Invoke(null, null); } catch { }
|
|
|
|
var typeSystem = tsField.GetValue(null);
|
|
var listField = typeSystem?.GetType().GetField("_assemblies", Flags);
|
|
var assemblies = listField?.GetValue(typeSystem) as IList;
|
|
if (assemblies == null) return _droppedAssemblies = Array.Empty<string>();
|
|
|
|
var doomed = new List<object>();
|
|
foreach (var entry in assemblies)
|
|
{
|
|
if (entry == null) continue;
|
|
var clr = entry.GetType().GetProperty("Assembly", Flags)?.GetValue(entry) as Assembly;
|
|
if (clr == null) continue;
|
|
try
|
|
{
|
|
clr.GetExportedTypes();
|
|
}
|
|
catch
|
|
{
|
|
doomed.Add(entry);
|
|
dropped.Add(clr.GetName().Name);
|
|
}
|
|
}
|
|
|
|
foreach (var entry in doomed) assemblies.Remove(entry);
|
|
|
|
// Re-run initialization now that the type system can be walked end to
|
|
// end. The first attempt aborted partway, leaving the xmlns mappings
|
|
// and emit context unset; this pass completes them.
|
|
if (doomed.Count > 0) initSre.Invoke(null, null);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Diagnostics.Trace.WriteLine("SanitizeXamlTypeSystem skipped: " + ex.Message);
|
|
}
|
|
|
|
return _droppedAssemblies = dropped.ToArray();
|
|
}
|
|
|
|
public static object LoadXaml(string xaml, string baseUri = null)
|
|
{
|
|
EnsureSetup();
|
|
Uri uri = baseUri != null ? new Uri(baseUri) : null;
|
|
return AvaloniaRuntimeXamlLoader.Load(xaml, localAssembly: null, rootInstance: null, uri: uri);
|
|
}
|
|
|
|
// Parse a Styles or ResourceDictionary file and merge it into Application.Current.
|
|
// Used to load theme files so XAML across the app can resolve {DynamicResource ...}
|
|
// lookups for brushes and pick up control style setters.
|
|
public static void LoadStyles(string xamlPath)
|
|
{
|
|
EnsureSetup();
|
|
var text = File.ReadAllText(xamlPath);
|
|
var uri = new Uri(new Uri("file:///" + xamlPath.Replace('\\', '/')).AbsoluteUri);
|
|
var obj = AvaloniaRuntimeXamlLoader.Load(text, localAssembly: null, rootInstance: null, uri: uri);
|
|
switch (obj)
|
|
{
|
|
case Avalonia.Styling.Styles styles:
|
|
Application.Current.Styles.Add(styles);
|
|
break;
|
|
case Avalonia.Styling.Style style:
|
|
Application.Current.Styles.Add(style);
|
|
break;
|
|
case Avalonia.Controls.ResourceDictionary rd:
|
|
Application.Current.Resources.MergedDictionaries.Add(rd);
|
|
break;
|
|
default:
|
|
throw new InvalidOperationException(
|
|
"LoadStyles: expected Styles, Style, or ResourceDictionary in " + xamlPath +
|
|
"; got " + (obj?.GetType().FullName ?? "null"));
|
|
}
|
|
}
|
|
|
|
public static object FindByName(object root, string name)
|
|
{
|
|
if (root is not Control control) return null;
|
|
return (object)control.FindControl<Control>(name) ?? control.FindNameScope()?.Find(name);
|
|
}
|
|
|
|
[DllImport("user32.dll")]
|
|
private static extern bool EnableWindow(IntPtr hWnd, bool bEnable);
|
|
[DllImport("user32.dll")]
|
|
private static extern bool SetForegroundWindow(IntPtr hWnd);
|
|
|
|
private static IntPtr GetHwnd(Window w) =>
|
|
w?.TryGetPlatformHandle() is { } h ? h.Handle : IntPtr.Zero;
|
|
|
|
// Run the main window: assigns it as MainWindow, calls lifetime.Start which
|
|
// blocks pumping the dispatcher loop until the last window closes.
|
|
public static int RunMainWindow(Window window)
|
|
{
|
|
EnsureSetup();
|
|
_lifetime.MainWindow = window;
|
|
return _lifetime.Start(Array.Empty<string>());
|
|
}
|
|
|
|
// Run a short, bounded nested dispatcher loop. Dispatcher.RunJobs() only
|
|
// drains work that has already reached Avalonia's managed queue; it does not
|
|
// provide the platform event loop needed to turn native mouse/keyboard input
|
|
// into routed events while synchronous PowerShell code owns the UI thread.
|
|
// Authentication waits call this repeatedly so their status-overlay Cancel
|
|
// button remains genuinely clickable without allowing an unbounded nested
|
|
// loop or moving PowerShell state onto another thread.
|
|
public static void PumpEventsOnce(int maximumMilliseconds = 10)
|
|
{
|
|
EnsureSetup();
|
|
if (!Dispatcher.UIThread.CheckAccess())
|
|
throw new InvalidOperationException("PumpEventsOnce must run on the Avalonia UI thread.");
|
|
|
|
maximumMilliseconds = Math.Clamp(maximumMilliseconds, 1, 50);
|
|
var frame = new DispatcherFrame();
|
|
var timer = new DispatcherTimer
|
|
{
|
|
Interval = TimeSpan.FromMilliseconds(maximumMilliseconds)
|
|
};
|
|
|
|
EventHandler tick = null;
|
|
tick = (_, _) =>
|
|
{
|
|
timer.Stop();
|
|
timer.Tick -= tick;
|
|
frame.Continue = false;
|
|
};
|
|
|
|
timer.Tick += tick;
|
|
timer.Start();
|
|
try
|
|
{
|
|
Dispatcher.UIThread.PushFrame(frame);
|
|
}
|
|
finally
|
|
{
|
|
timer.Stop();
|
|
timer.Tick -= tick;
|
|
frame.Continue = false;
|
|
}
|
|
}
|
|
|
|
// Modal-style dialog: use Avalonia's owned ShowDialog so the owner remains
|
|
// visually stable, then pump a nested DispatcherFrame until the dialog closes.
|
|
// Avalonia's Window.ShowDialog<T>(owner) returns a Task and is awkward to
|
|
// await synchronously; this approach gives sync semantics matching WPF.
|
|
public static void ShowDialog(Window dialog, Window owner = null)
|
|
{
|
|
EnsureSetup();
|
|
|
|
var frame = new DispatcherFrame();
|
|
|
|
if (owner != null)
|
|
{
|
|
dialog.WindowStartupLocation = WindowStartupLocation.Manual;
|
|
dialog.Position = new PixelPoint(
|
|
owner.Position.X + 40,
|
|
owner.Position.Y + 40);
|
|
}
|
|
|
|
if (owner != null)
|
|
{
|
|
dialog.ShowDialog(owner).ContinueWith(_ =>
|
|
Dispatcher.UIThread.Post(() => frame.Continue = false));
|
|
}
|
|
else
|
|
{
|
|
dialog.Closed += (_, _) => frame.Continue = false;
|
|
dialog.Show();
|
|
}
|
|
|
|
Dispatcher.UIThread.PushFrame(frame);
|
|
}
|
|
|
|
// Synchronous folder picker. The async StorageProvider API is awkward to
|
|
// bridge to a PowerShell caller that needs a return value; same approach
|
|
// as ShowDialog — push a nested DispatcherFrame, set Continue=false on the
|
|
// UI thread once the task completes.
|
|
public static string OpenFolderPicker(Window owner, string title)
|
|
{
|
|
return OpenFolderPicker(owner, title, null);
|
|
}
|
|
|
|
public static string OpenFolderPicker(Window owner, string title, string suggestedStartFolder)
|
|
{
|
|
EnsureSetup();
|
|
var topLevel = owner != null ? TopLevel.GetTopLevel(owner) : null;
|
|
if (topLevel?.StorageProvider == null) return null;
|
|
|
|
var options = new FolderPickerOpenOptions
|
|
{
|
|
AllowMultiple = false,
|
|
Title = string.IsNullOrEmpty(title) ? "Select folder" : title
|
|
};
|
|
|
|
// Folder resolution and the picker run in one async flow - blocking on
|
|
// TryGetFolderFromPathAsync before the frame is pushed would deadlock the
|
|
// dispatcher thread (see SaveFilePicker).
|
|
async Task<string> PickAsync()
|
|
{
|
|
if (!string.IsNullOrEmpty(suggestedStartFolder) && Directory.Exists(suggestedStartFolder))
|
|
{
|
|
try
|
|
{
|
|
var folder = await topLevel.StorageProvider.TryGetFolderFromPathAsync(new Uri(suggestedStartFolder));
|
|
if (folder != null) options.SuggestedStartLocation = folder;
|
|
}
|
|
catch { /* swallow - picker just opens in default location */ }
|
|
}
|
|
|
|
var picked = await topLevel.StorageProvider.OpenFolderPickerAsync(options);
|
|
return (picked != null && picked.Count > 0) ? picked[0].Path.LocalPath : null;
|
|
}
|
|
|
|
string result = null;
|
|
var frame = new DispatcherFrame();
|
|
|
|
PickAsync().ContinueWith(t =>
|
|
{
|
|
string r = (t.Status == TaskStatus.RanToCompletion) ? t.Result : null;
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
result = r;
|
|
frame.Continue = false;
|
|
});
|
|
});
|
|
|
|
Dispatcher.UIThread.PushFrame(frame);
|
|
return result;
|
|
}
|
|
|
|
// Copy text to the system clipboard. Called from the UI thread while the
|
|
// auth flow surfaces a device-code; like the pickers we run the async
|
|
// Clipboard API under a nested DispatcherFrame rather than blocking on it
|
|
// (a GetResult() on the UI thread would deadlock the continuation). Uses
|
|
// Avalonia's clipboard (X11/Wayland direct) so it works on a bare Linux box
|
|
// where PowerShell's Set-Clipboard is a no-op.
|
|
public static void SetClipboardText(Window owner, string text)
|
|
{
|
|
EnsureSetup();
|
|
var topLevel = owner != null ? TopLevel.GetTopLevel(owner) : null;
|
|
var clipboard = topLevel?.Clipboard;
|
|
if (clipboard == null) return;
|
|
|
|
var frame = new DispatcherFrame();
|
|
clipboard.SetTextAsync(text ?? string.Empty).ContinueWith(_ =>
|
|
Dispatcher.UIThread.Post(() => frame.Continue = false));
|
|
Dispatcher.UIThread.PushFrame(frame);
|
|
}
|
|
|
|
// Synchronous open-file picker. Single-select. filterName/filterPattern
|
|
// mirror SaveFilePicker — display name + semicolon-separated patterns.
|
|
// Returns null on cancel.
|
|
public static string OpenFilePicker(Window owner, string title, string suggestedStartFolder, string filterName, string filterPattern)
|
|
{
|
|
EnsureSetup();
|
|
var topLevel = owner != null ? TopLevel.GetTopLevel(owner) : null;
|
|
if (topLevel?.StorageProvider == null) return null;
|
|
|
|
var options = new FilePickerOpenOptions
|
|
{
|
|
Title = string.IsNullOrEmpty(title) ? "Open file" : title,
|
|
AllowMultiple = false
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(filterName) && !string.IsNullOrEmpty(filterPattern))
|
|
{
|
|
options.FileTypeFilter = new[]
|
|
{
|
|
new FilePickerFileType(filterName)
|
|
{
|
|
Patterns = filterPattern.Split(';', StringSplitOptions.RemoveEmptyEntries)
|
|
}
|
|
};
|
|
}
|
|
|
|
// One async flow - see SaveFilePicker for why this must not block.
|
|
async Task<string> PickAsync()
|
|
{
|
|
if (!string.IsNullOrEmpty(suggestedStartFolder) && Directory.Exists(suggestedStartFolder))
|
|
{
|
|
try
|
|
{
|
|
var folder = await topLevel.StorageProvider.TryGetFolderFromPathAsync(new Uri(suggestedStartFolder));
|
|
if (folder != null) options.SuggestedStartLocation = folder;
|
|
}
|
|
catch { /* swallow - picker just opens in default location */ }
|
|
}
|
|
|
|
var picked = await topLevel.StorageProvider.OpenFilePickerAsync(options);
|
|
return (picked != null && picked.Count > 0) ? picked[0].Path.LocalPath : null;
|
|
}
|
|
|
|
string result = null;
|
|
var frame = new DispatcherFrame();
|
|
|
|
PickAsync().ContinueWith(t =>
|
|
{
|
|
string r = (t.Status == TaskStatus.RanToCompletion) ? t.Result : null;
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
result = r;
|
|
frame.Continue = false;
|
|
});
|
|
});
|
|
|
|
Dispatcher.UIThread.PushFrame(frame);
|
|
return result;
|
|
}
|
|
|
|
// Synchronous save-file picker. filterName/filterPattern model the WPF
|
|
// "Json (*.json)|*.json" pairs: callers pass a display name and a
|
|
// semicolon-separated list of patterns ("*.json;*.txt").
|
|
// Keeps the original 6-argument signature working; forwards with no start folder.
|
|
public static string SaveFilePicker(Window owner, string title, string suggestedFileName, string defaultExtension, string filterName, string filterPattern)
|
|
{
|
|
return SaveFilePicker(owner, title, suggestedFileName, defaultExtension, filterName, filterPattern, null);
|
|
}
|
|
|
|
public static string SaveFilePicker(Window owner, string title, string suggestedFileName, string defaultExtension, string filterName, string filterPattern, string suggestedStartFolder)
|
|
{
|
|
EnsureSetup();
|
|
var topLevel = owner != null ? TopLevel.GetTopLevel(owner) : null;
|
|
if (topLevel?.StorageProvider == null) return null;
|
|
|
|
var options = new FilePickerSaveOptions
|
|
{
|
|
Title = string.IsNullOrEmpty(title) ? "Save" : title,
|
|
SuggestedFileName = suggestedFileName,
|
|
DefaultExtension = defaultExtension
|
|
};
|
|
|
|
if (!string.IsNullOrEmpty(filterName) && !string.IsNullOrEmpty(filterPattern))
|
|
{
|
|
options.FileTypeChoices = new[]
|
|
{
|
|
new FilePickerFileType(filterName)
|
|
{
|
|
Patterns = filterPattern.Split(';', StringSplitOptions.RemoveEmptyEntries)
|
|
}
|
|
};
|
|
}
|
|
|
|
// Resolve the start folder (WPF's InitialDirectory) and show the picker in
|
|
// ONE async flow. Blocking on TryGetFolderFromPathAsync before the frame is
|
|
// pushed would deadlock: this runs on the dispatcher thread, so any
|
|
// continuation the storage provider posts back to it could never run.
|
|
async Task<string> PickAsync()
|
|
{
|
|
if (!string.IsNullOrEmpty(suggestedStartFolder) && Directory.Exists(suggestedStartFolder))
|
|
{
|
|
try
|
|
{
|
|
var startFolder = await topLevel.StorageProvider.TryGetFolderFromPathAsync(new Uri(suggestedStartFolder));
|
|
if (startFolder != null) options.SuggestedStartLocation = startFolder;
|
|
}
|
|
catch { /* swallow - picker just opens in the default location */ }
|
|
}
|
|
|
|
var file = await topLevel.StorageProvider.SaveFilePickerAsync(options);
|
|
return file?.Path.LocalPath;
|
|
}
|
|
|
|
string result = null;
|
|
var frame = new DispatcherFrame();
|
|
|
|
PickAsync().ContinueWith(t =>
|
|
{
|
|
string r = (t.Status == TaskStatus.RanToCompletion) ? t.Result : null;
|
|
Dispatcher.UIThread.Post(() =>
|
|
{
|
|
result = r;
|
|
frame.Continue = false;
|
|
});
|
|
});
|
|
|
|
Dispatcher.UIThread.PushFrame(frame);
|
|
return result;
|
|
}
|
|
|
|
public static void Shutdown()
|
|
{
|
|
if (!_setup) return;
|
|
_lifetime?.Shutdown();
|
|
}
|
|
|
|
// Factory for IntunePolicyPathConverter: PowerShell's [FullName]::new()
|
|
// resolution walks every loaded assembly and calls GetTypes() on each.
|
|
// After Avalonia's runtime XAML loader has compiled .axaml files into
|
|
// dynamic assemblies, GetTypes() on those throws ReflectionTypeLoadException
|
|
// and the PS resolution fails. Routing through this factory reuses the
|
|
// already-resolved Host type (assigned to $script:AvaloniaHostType at
|
|
// init time, before any XAML compilation), so no fresh scan happens.
|
|
public static IValueConverter CreatePathConverter() => new IntunePolicyPathConverter();
|
|
|
|
private static void EnsureSetup()
|
|
{
|
|
if (!_setup)
|
|
{
|
|
throw new InvalidOperationException(
|
|
"AvaloniaHost is not initialized. Call IntuneManagement.AvaloniaHost.Host.Initialize() first.");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Walks a dotted property path on an arbitrary value (CLR object or PSObject).
|
|
// Used by the Intune Manager DataGrid for the user-defined "ObjectColumns"
|
|
// override — those paths reach into the original IntunePolicyBase / its
|
|
// underlying PSCustomObject (`Object`) and so do not resolve against the
|
|
// canonical fields on IntuneObjectRowItem. The binding points at the row's
|
|
// `Source` and passes the path string as ConverterParameter; this converter
|
|
// steps through PSObject.Properties at each segment, which catches both CLR
|
|
// properties and PSObject NoteProperties (Avalonia's binder ignores the
|
|
// latter on its own — see avalonia-binding-needs-clr-types).
|
|
//
|
|
// Lives in C# because PowerShell `class X : SomeAvaloniaType` resolves the
|
|
// base type at parse time, before Initialize-AvaloniaRuntime has loaded the
|
|
// Avalonia assemblies.
|
|
//
|
|
// PSObject access is via late-bound reflection rather than a compile-time
|
|
// reference to System.Management.Automation: that assembly's transitive
|
|
// references (e.g. System.Linq.Expressions v10) outpace the .NET ref-pack
|
|
// shipped with the SDK (v8), and Roslyn rejects the cross-version mismatch
|
|
// with CS1705. Reflection sidesteps the compile-time check entirely.
|
|
public sealed class IntunePolicyPathConverter : IValueConverter
|
|
{
|
|
private static readonly Type _psObjectType =
|
|
Type.GetType("System.Management.Automation.PSObject, System.Management.Automation");
|
|
private static readonly MethodInfo _asPSObject =
|
|
_psObjectType?.GetMethod("AsPSObject", new[] { typeof(object) });
|
|
private static readonly PropertyInfo _propertiesProp =
|
|
_psObjectType?.GetProperty("Properties");
|
|
|
|
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
if (value == null || parameter == null) return null;
|
|
var path = parameter.ToString();
|
|
if (string.IsNullOrWhiteSpace(path)) return null;
|
|
|
|
object current = value;
|
|
foreach (var segment in path.Split('.'))
|
|
{
|
|
if (current == null) return null;
|
|
|
|
object next = null;
|
|
try
|
|
{
|
|
if (TryGetPSProperty(current, segment, out var psValue))
|
|
{
|
|
next = psValue;
|
|
}
|
|
else
|
|
{
|
|
var clrType = current.GetType();
|
|
var clrProp = clrType.GetProperty(segment);
|
|
if (clrProp != null)
|
|
{
|
|
next = clrProp.GetValue(current);
|
|
}
|
|
else
|
|
{
|
|
var clrField = clrType.GetField(segment);
|
|
if (clrField != null)
|
|
{
|
|
next = clrField.GetValue(current);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
current = next;
|
|
}
|
|
|
|
if (current == null) return null;
|
|
if (current is string || current.GetType().IsPrimitive) return current;
|
|
return current.ToString();
|
|
}
|
|
|
|
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
private static bool TryGetPSProperty(object instance, string name, out object value)
|
|
{
|
|
value = null;
|
|
if (_psObjectType == null || _asPSObject == null || _propertiesProp == null)
|
|
return false;
|
|
|
|
var psObj = _asPSObject.Invoke(null, new[] { instance });
|
|
if (psObj == null) return false;
|
|
|
|
var properties = _propertiesProp.GetValue(psObj);
|
|
if (properties == null) return false;
|
|
|
|
var indexer = properties.GetType().GetProperty("Item", new[] { typeof(string) });
|
|
var prop = indexer?.GetValue(properties, new object[] { name });
|
|
if (prop == null) return false;
|
|
|
|
var valueProp = prop.GetType().GetProperty("Value");
|
|
if (valueProp == null) return false;
|
|
|
|
value = valueProp.GetValue(prop);
|
|
return true;
|
|
}
|
|
}
|