it-swarm.com.de

Bester Weg, um IPEndpoint aus Zeichenfolge zu erstellen

Da IPEndpoint eine ToString()-Methode enthält, die Folgendes ausgibt:

10.10.10.10: 1010

Es sollte auch eine Parse()- und/oder TryParse()-Methode geben, aber es gibt keine.

Ich kann die Zeichenfolge in : aufteilen und eine IP-Adresse und einen Port analysieren.

Aber gibt es einen eleganteren Weg?

35
sbhl

Dies ist eine Lösung ...

public static IPEndPoint CreateIPEndPoint(string endPoint)
{
    string[] ep = endPoint.Split(':');
    if(ep.Length != 2) throw new FormatException("Invalid endpoint format");
    IPAddress ip;
    if(!IPAddress.TryParse(ep[0], out ip))
    {
        throw new FormatException("Invalid ip-adress");
    }
    int port;
    if(!int.TryParse(ep[1], NumberStyles.None, NumberFormatInfo.CurrentInfo, out port))
    {
        throw new FormatException("Invalid port");
    }
    return new IPEndPoint(ip, port);
}

Bearbeiten: Es wurde eine Version hinzugefügt, die IPv4 und IPv6 unterstützt. Die vorherige Version behandelt nur IPv4.

// Handles IPv4 and IPv6 notation.
public static IPEndPoint CreateIPEndPoint(string endPoint)
{
    string[] ep = endPoint.Split(':');
    if (ep.Length < 2) throw new FormatException("Invalid endpoint format");
    IPAddress ip;
    if (ep.Length > 2)
    {
        if (!IPAddress.TryParse(string.Join(":", ep, 0, ep.Length - 1), out ip))
        {
            throw new FormatException("Invalid ip-adress");
        }
    }
    else
    {
        if (!IPAddress.TryParse(ep[0], out ip))
        {
            throw new FormatException("Invalid ip-adress");
        }
    }
    int port;
    if (!int.TryParse(ep[ep.Length - 1], NumberStyles.None, NumberFormatInfo.CurrentInfo, out port))
    {
        throw new FormatException("Invalid port");
    }
    return new IPEndPoint(ip, port);
}
26
Jens Granlund

Ich hatte die Anforderung, einen IPEndpoint mit IPv6, v4 und Hostnamen zu analysieren. Die Lösung, die ich geschrieben habe, ist unten aufgeführt:

    public static IPEndPoint Parse(string endpointstring)
    {
        return Parse(endpointstring, -1);
    }

    public static IPEndPoint Parse(string endpointstring, int defaultport)
    {
        if (string.IsNullOrEmpty(endpointstring)
            || endpointstring.Trim().Length == 0)
        {
            throw new ArgumentException("Endpoint descriptor may not be empty.");
        }

        if (defaultport != -1 &&
            (defaultport < IPEndPoint.MinPort
            || defaultport > IPEndPoint.MaxPort))
        {
            throw new ArgumentException(string.Format("Invalid default port '{0}'", defaultport));
        }

        string[] values = endpointstring.Split(new char[] { ':' });
        IPAddress ipaddy;
        int port = -1;

        //check if we have an IPv6 or ports
        if (values.Length <= 2) // ipv4 or hostname
        {
            if (values.Length == 1)
                //no port is specified, default
                port = defaultport;
            else
                port = getPort(values[1]);

            //try to use the address as IPv4, otherwise get hostname
            if (!IPAddress.TryParse(values[0], out ipaddy))
                ipaddy = getIPfromHost(values[0]);
        }
        else if (values.Length > 2) //ipv6
        {
            //could [a:b:c]:d
            if (values[0].StartsWith("[") && values[values.Length - 2].EndsWith("]"))
            {
                string ipaddressstring = string.Join(":", values.Take(values.Length - 1).ToArray());
                ipaddy = IPAddress.Parse(ipaddressstring);
                port = getPort(values[values.Length - 1]);
            }
            else //[a:b:c] or a:b:c
            {
                ipaddy = IPAddress.Parse(endpointstring);
                port = defaultport;
            }
        }
        else
        {
            throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", endpointstring));
        }

        if (port == -1)
            throw new ArgumentException(string.Format("No port specified: '{0}'", endpointstring));

        return new IPEndPoint(ipaddy, port);
    }

    private static int getPort(string p)
    {
        int port;

        if (!int.TryParse(p, out port)
         || port < IPEndPoint.MinPort
         || port > IPEndPoint.MaxPort)
        {
            throw new FormatException(string.Format("Invalid end point port '{0}'", p));
        }

        return port;
    }

    private static IPAddress getIPfromHost(string p)
    {
        var hosts = Dns.GetHostAddresses(p);

        if (hosts == null || hosts.Length == 0)
            throw new ArgumentException(string.Format("Host not found: {0}", p));

        return hosts[0];
    }

Dies wurde getestet, um mit den folgenden Beispielen zu arbeiten:

  • 0.0.0.0: 100
  • 0,0,0,0
  • [:: 1]: 100
  • [:: 1]
  • :: 1
  • [A B C D]
  • [a: b: c: d]: 100
  • beispiel.org
  • beispiel.org: 100
25
Mitch

Anscheinend gibt es bereits eine eingebaute Parse-Methode, die IP4- und IP6-Adressen verarbeitet http://msdn.Microsoft.com/en-us/library/system.net.ipaddress.parse%28v=vs. 110% 29.aspx

// serverIP can be in ip4 or ip6 format
string serverIP = "192.168.0.1";
string port = 8000;
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Parse(serverIP), port);
9
Beach Miles

Hier ist meine Version des Parsens von Text in IPEndPoint:

private static IPEndPoint ParseIPEndPoint(string text)
{
    Uri uri;
    if (Uri.TryCreate(text, UriKind.Absolute, out uri))
        return new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port < 0 ? 0 : uri.Port);
    if (Uri.TryCreate(String.Concat("tcp://", text), UriKind.Absolute, out uri))
        return new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port < 0 ? 0 : uri.Port);
    if (Uri.TryCreate(String.Concat("tcp://", String.Concat("[", text, "]")), UriKind.Absolute, out uri))
        return new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port < 0 ? 0 : uri.Port);
    throw new FormatException("Failed to parse text to IPEndPoint");
}

Getestet mit:

3
Gabrielius

Dies wird IPv4 und IPv6 tun. Eine Erweiterungsmethode für diese Funktionalität befindet sich in System.string. Ich bin mir nicht sicher, ob ich diese Option für jeden String, den ich im Projekt habe, möchte.

private static IPEndPoint IPEndPointParse(string endpointstring)
{
    string[] values = endpointstring.Split(new char[] {':'});

    if (2 > values.Length)
    {
        throw new FormatException("Invalid endpoint format");
    }

    IPAddress ipaddress;
    string ipaddressstring = string.Join(":", values.Take(values.Length - 1).ToArray());
    if (!IPAddress.TryParse(ipaddressstring, out ipaddress))
    {
        throw new FormatException(string.Format("Invalid endpoint ipaddress '{0}'", ipaddressstring));
    }

    int port;
    if (!int.TryParse(values[values.Length - 1], out port)
     || port < IPEndPoint.MinPort
     || port > IPEndPoint.MaxPort)
    {
        throw new FormatException(string.Format("Invalid end point port '{0}'", values[values.Length - 1]));
    }

    return new IPEndPoint(ipaddress, port);
}
2
Greg Bogumil

Wenn die Portnummer immer nach einem ':' angegeben wird, kann die folgende Methode eine elegantere Option sein (in Codelänge statt in Effizienz).

public static IPEndpoint ParseIPEndpoint(string ipEndPoint) {
    int ipAddressLength = ipEndPoint.LastIndexOf(':');
    return new IPEndPoint(
        IPAddress.Parse(ipEndPoint.Substring(0, ipAddressLength)),
        Convert.ToInt32(ipEndPoint.Substring(ipAddressLength + 1)));
}

Es funktioniert gut für meine einfache Anwendung, ohne das komplexe IP-Adressformat zu berücksichtigen.

1
Mr. Ree

Dies ist meine Meinung zum Parsen eines IPEndPoint. Durch die Verwendung der Uri-Klasse müssen die Besonderheiten von IPv4/6 und der Anschluss des Ports nicht beachtet werden. Sie können den Standardport für Ihre Anwendung ändern.

    public static bool TryParseEndPoint(string ipPort, out System.Net.IPEndPoint result)
    {
        result = null;

        string scheme = "iiiiiiiiiaigaig";
        GenericUriParserOptions options =
            GenericUriParserOptions.AllowEmptyAuthority |
            GenericUriParserOptions.NoQuery |
            GenericUriParserOptions.NoUserInfo |
            GenericUriParserOptions.NoFragment |
            GenericUriParserOptions.DontCompressPath |
            GenericUriParserOptions.DontConvertPathBackslashes |
            GenericUriParserOptions.DontUnescapePathDotsAndSlashes;
        UriParser.Register(new GenericUriParser(options), scheme, 1337);

        Uri parsedUri;
        if (!Uri.TryCreate(scheme + "://" + ipPort, UriKind.Absolute, out parsedUri))
            return false;
        System.Net.IPAddress parsedIP;
        if (!System.Net.IPAddress.TryParse(parsedUri.Host, out parsedIP))
            return false;

        result = new System.Net.IPEndPoint(parsedIP, parsedUri.Port);
        return true;
    }
1
Djof

Der Analysecode ist für einen IPv4-Endpunkt einfach, aber IPEndPoint.ToString () für eine IPv6-Adresse verwendet dieselbe Doppelpunktnotation, steht jedoch in Konflikt mit der Doppelpunktnotation der IPv6-Adresse. Ich hatte gehofft, dass Microsoft die Mühe aufwenden würde, stattdessen diesen hässlichen Code zu analysieren, aber ich denke, ich muss ...

1
Erhhung

Erstellen Sie eine Erweiterungsmethode Parse und TryParse. Ich denke, das ist eleganter.

1
TrustyCoder

Offenbar wurden IPEndPoint.Parse und IPEndPoint.TryParsekürzlich in .NET Core 3.0 hinzugefügt .

Wenn Sie es anvisieren, probieren Sie diese Methoden aus! Die Implementierung ist im obigen Link zu sehen.

0
Ray Koopa

Hier ist eine sehr einfache Lösung, die sowohl IPv4 als auch IPv6 unterstützt.

public class IPEndPoint : System.Net.IPEndPoint
{
    public IPEndPoint(long address, int port) : base(address, port) { }
    public IPEndPoint(IPAddress address, int port) : base(address, port) { }

    public static bool TryParse(string value, out IPEndPoint result)
    {
        if (!Uri.TryCreate($"tcp://{value}", UriKind.Absolute, out Uri uri) ||
            !IPAddress.TryParse(uri.Host, out IPAddress ipAddress) ||
            uri.Port < 0 || uri.Port > 65535)
        {
            result = default(IPEndPoint);
            return false;
        }

        result = new IPEndPoint(ipAddress, uri.Port);
        return true;
    }
}

Verwenden Sie einfach die TryParse wie gewohnt.

IPEndPoint.TryParse("192.168.1.10:80", out IPEndPoint ipv4Result);
IPEndPoint.TryParse("[fd00::]:8080", out IPEndPoint ipv6Result);
0
Svek
using System;
using System.Net;

static class Helper {
  public static IPEndPoint ToIPEndPoint(this string value, int port = IPEndPoint.MinPort) {
    if (string.IsNullOrEmpty(value) || ! IPAddress.TryParse(value, out var address)) 
      return null;
    var offset = (value = value.Replace(address.ToString(), string.Empty)).LastIndexOf(':');
    if (offset >= 0)
      if (! int.TryParse(value.Substring(offset + 1), out port) || port < IPEndPoint.MinPort || port > IPEndPoint.MaxPort)
        return null;
    return new IPEndPoint(address, port);
  }
}

class Program {
  static void Main() {
    foreach (var sample in new [] {
      // See https://docops.ca.com/ca-data-protection-15/en/implementing/platform-deployment/technical-information/ipv6-address-and-port-formats
      "192.168.0.3",
      "fe80::214:c2ff:fec8:c920",
      "10.0.1.53-10.0.1.80",
      "10.0",
      "10/7",
      "2001:0db8:85a3/48",
      "192.168.0.5:10",
      "[fe80::e828:209d:20e:c0ae]:375",
      ":137-139",
      "192.168:1024-65535",
      "[fe80::]-[fe81::]:80"
    }) {
      var point = sample.ToIPEndPoint();
      var report = point == null ? "NULL" : [email protected]"IPEndPoint {{
  Address: {point.Address}
  AddressFamily: {point.AddressFamily}
  Port: {point.Port}
}}";
      Console.WriteLine([email protected]"""{sample}"" to IPEndPoint is {report}
");
    }
  }
}
0
Mega WEB