Thanks to Charlieface, I was able to create the following:

using System;
using System.Management.Automation;
using System.Management.Automation.Runspaces;
using System.Collections.ObjectModel;

class Program
{
    static void Main()
    {
        string remoteMachine = "RemoteMachine"; 
        string username = "user";               
        string password = "password";               

        // WSMan connection info
        PSCredential credentials = new PSCredential(username, new System.Security.SecureString());
        foreach (char c in password) credentials.Password.AppendChar(c);

        WSManConnectionInfo connectionInfo = new WSManConnectionInfo(
            new Uri($"http://{remoteMachine}:5985/wsman"),
            "http://schemas.microsoft.com/powershell/Microsoft.PowerShell",
            credentials
        );
        // Create a runspace with the WSMan connection
        Runspace runspace = RunspaceFactory.CreateRunspace(connectionInfo);
        runspace.Open();

        // Create the pipeline to execute the PowerShell command
        using (PowerShell pipeline = PowerShell.Create())
        {
            // Command to execute remotely
            pipeline.Runspace = runspace;
            // Add the Get-NetIPConfiguration command to the pipeline
            pipeline.AddCommand("Get-NetIPConfiguration");
            pipeline.AddCommand("Select-Object").AddParameter("Property", new string[] { "InterfaceAlias", "IPv4Address", "InterfaceIndex", "InterfaceDescription", "NetProfile", "IPv4DefaultGateway", "DNSServer" });

            try
            {
                Collection<PSObject> results = pipeline.Invoke();

                // Process results
                foreach (PSObject result in results)
                {
                    string interfaceAlias = result.Members["InterfaceAlias"]?.Value.ToString();

                    string ipv4Address = string.Empty;
                    string ipv4PrefixLength = string.Empty;
                    string ipv4Gateway = string.Empty;
                    string dnsServers = string.Empty;

                    var ipv4AddressObject = result.Members["IPv4Address"]?.Value as PSObject;
                    if (ipv4AddressObject != null)
                    {
                        var baseObject = ipv4AddressObject.BaseObject as dynamic;
                        ipv4Address = baseObject[0]?.IPAddress;
                        ipv4PrefixLength = baseObject[0]?.PrefixLength.ToString();
                    }

                    // Accessing Default Gateway
                    var ipv4GatewayObject = result.Members["IPv4DefaultGateway"]?.Value as PSObject;
                    if (ipv4GatewayObject != null)
                    {
                        var baseGatewayObject = ipv4GatewayObject.BaseObject as dynamic;
                        ipv4Gateway = baseGatewayObject[0]?.NextHop;
                    }

                    // Accessing DNS Servers
                    StringBuilder DNSServers = new StringBuilder();

                    var dnsServersObject = result.Members["DNSServer"]?.Value as PSObject;
                    if (dnsServersObject != null)
                    {
                        var baseDNSServersObject = dnsServersObject.BaseObject as dynamic;

                        if(baseDNSServersObject.Count > 1)
                        {
                            foreach(var DnsServerObject in baseDNSServersObject)
                            {
                                var baseDNSServers = DnsServerObject?.ServerAddresses;

                                if (baseDNSServers is object[] DnsServers)
                                {
                                    int? cnt = 1;
                                    foreach (var DnsServer in DnsServers)
                                    {
                                        string? DNS = null;

                                        if (cnt < DnsServers.Length)
                                        {
                                            DNS = DnsServer.ToString();
                                            DNS = DNS + ";";
                                        }
                                        else
                                        {
                                            DNS = DnsServer.ToString();
                                        }

                                        DNSServers.Append(DNS);
                                        cnt++;
                                    }
                                }
                            }
                        }
                        else
                        {
                            var baseDNSServers = baseDNSServersObject[0]?.ServerAddresses;

                            if (baseDNSServers is object[] DnsServers)
                            {
                                foreach (var DnsServer in DnsServers)
                                {
                                    string? DNS = DnsServer.ToString();
                                    DNSServers.Append(DNS);
                                }
                            }
                        }
                    }

                    // Convert CIDR to Subnet Mask
                    string subnetMask = CidrToMask(Convert.ToInt32(ipv4PrefixLength));

                    // Output results
                    Console.WriteLine($"InterfaceAlias     : {interfaceAlias}");
                    Console.WriteLine($"IPv4 Address       : {ipv4Address}");
                    Console.WriteLine($"Subnet Mask        : {subnetMask}");
                    Console.WriteLine($"Default Gateway    : {ipv4Gateway}");
                    Console.WriteLine($"DNSServer          : {DNSServers.ToString()}");
                    Console.WriteLine();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error executing the pipeline: " + ex);
            }
        }

        // Clean up and close the runspace
        runspace.Close();
    }
    public static string CidrToMask(int cidr)
    {
        var mask = (cidr == 0) ? 0 : uint.MaxValue << (32 - cidr);
        var bytes = BitConverter.GetBytes(mask).Reverse().ToArray();
        return new IPAddress(bytes).ToString();
    }