Учитывая List<string> ips = new List<string>();
Мне нужно отсортировать список IP-адресов в логическом порядке (т.е. "192.168.0.2" подходит до "192.168.0.100" ).
В настоящее время (и правильно, в алфавитном порядке), если список содержит:
192.168.0.1
192.168.0.2
192.168.0.10
192.168.0.200
ips.OrderBy(p => p) возвращает:
192.168.0.1
192.168.0.10
192.168.0.2
192.168.0.200
Вам нужно сделать сравнение: (Протестировано)
class IPComparer : IComparer<string> {
public int Compare(string a, string b) {
return Enumerable.Zip(a.Split('.'), b.Split('.'),
(x, y) => int.Parse(x).CompareTo(int.Parse(y)))
.FirstOrDefault(i => i != 0);
}
}
Затем вы можете написать
ips.OrderBy(p => p, new IPComparer())
Я бы создал компаратор для System.Net.IPAddress, например,
class IPAddressComparer : IComparer<IPAddress> {
public int Compare(IPAddress x, IPAddress y) {
byte[] first = x.GetAddressBytes();
byte[] second = y.GetAddressBytes();
return first.Zip(second, (a, b) => a.CompareTo(b))
.FirstOrDefault(c => c != 0);
}
}
а затем действуйте следующим образом:
var list = new List<string>() {
"192.168.0.1",
"192.168.0.10",
"192.168.0.2",
"192.168.0.200"
};
var sorted = list.OrderBy(s => IPAddress.Parse(s), new IPAddressComparer());
Вы можете разбить это на 4 целочисленных значения и отсортировать по очереди:
var results = ips
.Select(s => string.Split('.').Select(str => int.Parse(str)).ToArray() )
.OrderBy(intArray => intArray[0])
.ThenBy(intArray => intArray[1])
.ThenBy(intArray => intArray[2])
.ThenBy(intArray => intArray[3])
.Select(intArray => string.Join(".", intArray) );
Это довольно элегантно (и выдается подтверждение, если вы используете TryParse):
var sorted2 = from ip in ips
let addressBytes = IPAddress.Parse(ip).GetAddressBytes()
orderby addressBytes[0], addressBytes[1], addressBytes[2], addressBytes[3]
select ip;
Массив addressBytes будет иметь длину 4, если только это IP4-адреса. В противном случае вы должны учитывать длину...
Я написал IpComparer для IPv6. Вариант Howel не работает.
Вот сравнитель:
/// <summary>
/// Compares two ip addresses.
/// http://stackoverflow.com/questions/4785218/linq-lambda-orderby-delegate-for-liststring-of-ip-addresses
/// </summary>
public class IpComparer : IComparer<IPAddress>
{
/// <summary>
/// Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
/// </summary>
///
/// <returns>
/// A signed integer that indicates the relative values of <paramref name="x"/> and <paramref name="y"/>, as shown in the following table.
/// Value Meaning Less than zero<paramref name="x"/> is less than <paramref name="y"/>.
/// Zero<paramref name="x"/> equals <paramref name="y"/>.
/// Greater than zero <paramref name="x"/> is greater than <paramref name="y"/>.
/// </returns>
/// <param name="x">The first object to compare.</param><param name="y">The second object to compare.</param>
public int Compare(IPAddress x, IPAddress y)
{
if (ReferenceEquals(x, null))
{
throw new ArgumentNullException("x");
}
if (ReferenceEquals(y, null))
{
throw new ArgumentNullException("y");
}
byte[] bytesOfX = x.GetAddressBytes();
byte[] bytesOfY = y.GetAddressBytes();
return StructuralComparisons.StructuralComparer.Compare(bytesOfX, bytesOfY);
}
}
И здесь unit test:
[TestFixture]
public class IpComparerTest : AbstractUnitTest
{
private IpComparer _testee;
[SetUp]
public void Setup()
{
_testee = new IpComparer();
}
[TestCase("10.156.35.205", "10.156.35.205")]
[TestCase("0.0.0.1", "0.0.0.1")]
[TestCase("2001:0db8:0000:08d3:0000:8a2e:0070:7344", "2001:db8:0:8d3:0:8a2e:70:7344")]
[TestCase("2001:0db8:0:0:0:0:1428:57ab", "2001:db8::1428:57ab")]
[TestCase("2001:0db8:0:0:8d3:0:0:0", "2001:db8:0:0:8d3::")]
[TestCase("::ffff:127.0.0.1", "::ffff:7f00:1")]
public void Compare_WhenIpsAreEqual_ThenResultIsZero(string ip1, string ip2)
{
// Arrange
IPAddress x = IPAddress.Parse(ip1);
IPAddress y = IPAddress.Parse(ip2);
// Act and Assert
Assert.That(_testee.Compare(x, y), Is.EqualTo(0));
}
[TestCase("10.156.35.2", "10.156.35.205")]
[TestCase("0.0.0.0", "0.0.0.1")]
[TestCase("1001:0db8:85a3:08d3:1319:8a2e:0370:7344", "2001:0db8:85a3:08d3:1319:8a2e:0370:7344")]
[TestCase("2001:0db8:85a3:08d3:1319:8a2e:0370:7343", "2001:0db8:85a3:08d3:1319:8a2e:0370:7344")]
public void Compare_WhenIp1IsLessThanIp2_ThenResultIsLessThanZero(string ip1, string ip2)
{
// Arrange
IPAddress x = IPAddress.Parse(ip1);
IPAddress y = IPAddress.Parse(ip2);
// Act and Assert
Assert.That(_testee.Compare(x, y), Is.LessThan(0));
}
[TestCase("10.156.35.205", "10.156.35.2")]
[TestCase("0.0.0.1", "0.0.0.0")]
[TestCase("3001:0db8:85a3:08d3:1319:8a2e:0370:7344", "2001:0db8:85a3:08d3:1319:8a2e:0370:7344")]
[TestCase("2001:0db8:85a3:08d3:1319:8a2e:0370:7345", "2001:0db8:85a3:08d3:1319:8a2e:0370:7344")]
public void Compare_WhenIp1IsGreaterThanIp2_ThenResultIsGreaterThanZero(string ip1, string ip2)
{
// Arrange
IPAddress x = IPAddress.Parse(ip1);
IPAddress y = IPAddress.Parse(ip2);
// Act and Assert
Assert.That(_testee.Compare(x, y), Is.GreaterThan(0));
}
}
Я надеюсь, что это решение будет правильным. Я не эксперт в IPv6.
Это старый вопрос, но я искал IP Comparer, и он подошел. Я хотел кое-что, что работало для IPv6, хотя, хотя, как только я получил его, я думал, что добавлю его сюда для следующего человека, который ищет его. Как и SLaks, я согласен с тем, что IComparer, вероятно, лучше всего.
public class IPComparer : IComparer<IPAddress>
{
public int Compare(IPAddress x, IPAddress y)
{
if (ReferenceEquals(x, null))
throw new ArgumentNullException("x");
if (ReferenceEquals(y, null))
throw new ArgumentNullException("y");
return BitConverter.ToUInt32(x.GetAddressBytes().Reverse().ToArray(),0)
.CompareTo(BitConverter.ToUInt32(y.GetAddressBytes().Reverse().ToArray(),0));
}
}
Ничего особенного, но он должен работать.