grpc helper

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using pb = global::Google.Protobuf;

 
public class NetworkHelperA {
    public NetworkHelperA () {
        // _dispatcher = Dispatcher.construct ();
    }

    public static bool isPrivateNetwork (string address) => IPAddress.TryParse (address, out var ip) && ip.AddressFamily switch {
        AddressFamily.InterNetwork => isPrivateNetwork4 (ip),
        AddressFamily.InterNetworkV6 => isPrivateNetwork6 (ip),
        _ => false
    };

    public static bool isPrivateNetwork (IPAddress address) => address.AddressFamily switch {
        AddressFamily.InterNetwork => isPrivateNetwork4 (address),
        AddressFamily.InterNetworkV6 => isPrivateNetwork6 (address),
        _ => false
    };

    private static bool isPrivateNetwork4 (IPAddress ipv4Address) => ipv4Address.GetAddressBytes () switch {
        var x when x [0] == 10 => true,
        var x when x [0] == 127 => true,
        var x when x [0] == 172 && x [1] >= 16 && x [1] <= 31 => true,
        var x when x [0] == 192 && x [1] == 168 => true,
        _ => false
    };

    private static bool isPrivateNetwork6 (IPAddress address) {
        // Make sure we are dealing with an IPv6 address
        var addressAsString = address.ToString ();
        var firstWord = addressAsString.Split (new [] { ':' }, StringSplitOptions.RemoveEmptyEntries) [0];

        bool flag;
        // equivalent of 127.0.0.1 in IPv6
        if (addressAsString == "::1") {
            flag = true;
        }
        // The original IPv6 Site Local addresses (fec0::/10) are deprecated. Unfortunately IsIPv6SiteLocal only checks for the original deprecated version:
        else if (address.IsIPv6SiteLocal) {
            flag = true;
        }
        // These days Unique Local Addresses (ULA) are used in place of Site Local.
        // ULA has two variants:
        //      fc00::/8 is not defined yet, but might be used in the future for internal-use addresses that are registered in a central place (ULA Central).
        //      fd00::/8 is in use and does not have to registered anywhere.
        else if (firstWord.Length >= 4 && firstWord [..2] == "fc") {
            flag = true;
        } else if (firstWord.Length >= 4 && firstWord [..2] == "fd") {
            flag = true;
        }
          // Link local addresses (prefixed with fe80) are not routable
          else if (firstWord == "fe80") {
            flag = true;
        }
          // Discard Prefix
          else if (firstWord == "100") {
            flag = true;
        } else if (firstWord == "ffff") {
            flag = true;
        } else {
            // Any other IP address is not Unique Local Address (ULA)
            flag = false;
        }

        return flag;
    }


    public static pb::IMessage? readMessage (pb::MessageParser parser, byte [] buffer, int offset = 0, int length = -1) {
        if (buffer == null) {
            return null;
        }

        if (length == -1) {
            length = buffer.Length;
        }
        var result = parser.ParseFrom (buffer, offset, length);

        return result;
    }

    public static T? readMessage<T> (byte [] buffer, int offset = 0, int length = -1) where T : class, pb.IMessage<T>, new() {
        if (buffer == null) {
            return null;
        }

        if (length == -1) {
            length = buffer.Length;
        }

        var parser = new pb::MessageParser<T> (() => new T ());

        T? result = null;
        result = parser.ParseFrom (buffer, offset, length);

        return result;
    }

    public static byte []? serializeMessage (pb::IMessage message) {
        if (message == null) {
            return Array.Empty<byte> ();
        }

        byte []? result = null;
        using (var packetStream = new MemoryStream ()) {
            using var stream = new pb.CodedOutputStream (packetStream);
            message.WriteTo (stream);
            stream.Flush ();

            result = new byte [packetStream.Length];
            packetStream.Seek (0, 0);
            packetStream.ReadAsync (result, 0, result.Length);
        }

        return result;
    }
}