两个字符串比大小

[caian12345]

//写个方法让字符串1.0.0.15 大于字符串1.0.0.2

//比如1.0.22.1要大于1.0.3.8

[caian12345]

[Quote=引用 11 楼 的回复:]
.拆分 然后弄成数组 a{1,2,3,4} b{1,2,3,4}
a1和b2比 a2和b2比 类推 我只说个原理
[/Quote]

这个晓得，就不会。。。

[q107770540]

您未说清楚规则

[qlzf11140820]

Version vsA = new Version(strA)
Version vsB = new Version(strB)
vsA.CompareTo(vsB)

[zllllz6]

string a = "2.1.45.6";
            string b = "3.1.3.7";
            string[] aa = a.Split('.');
            string[] bb = b.Split('.');
            string sum = "";
            for (int i = 0; i < aa.Length; i++)
            {
                if (int.Parse(aa[i].ToString())>int.Parse(bb[i].ToString()))
                {
                    sum= "a>b";
                }
                else
                {
                    sum = "b>a";
                }
            }

[caian12345]

[Quote=引用 13 楼 的回复:]
您未说清楚规则
[/Quote]
好吧，我错了。

[zllllz6]

[Quote=引用 16 楼 的回复:]

C# code

string a = "2.1.45.6";
string b = "3.1.3.7";
string[] aa = a.Split('.');
string[] bb = b.Split('.');
string sum = "";
for (int i ……
[/Quote]
if 里边加个break;```
这个我都忘记了悲剧

[zllllz6]

string a = "2.1.45.6";
            string b = "3.1.3.7";
            string[] aa = a.Split('.');
            string[] bb = b.Split('.');
            string sum = "";
            for (int i = 0; i < aa.Length; i++)
            {
                if (int.Parse(aa[i].ToString())>int.Parse(bb[i].ToString()))
                {
                    sum= "a>b";
                    break;
                }
                else
                {
                    sum = "b>a";
                }
            }

[dalmeeme]

其实很简单，Split('.')拆分成一个string数组，然后循环遍历每个元素，依次比较其整形值即可。

还有一种方法，如果每一段的值最多3位，那么拆分string数组后，再填充指定位宽合并，比较最后的字符串大小即可。

[zllllz6]

string a = "2.1.45.6";
            string b = "3.1.3.7";
            string[] aa = a.Split('.');
            string[] bb = b.Split('.');
            string sum = "";
            for (int i = 0; i < aa.Length; i++)
            {
                if (int.Parse(aa[i].ToString()) != int.Parse(bb[i].ToString()))
                {
                    if (int.Parse(aa[i].ToString()) > int.Parse(bb[i].ToString()))
                    {
                        sum = "a>b";
                    }
                    else 
                    {
                        sum = "b>a";
                    }
                    break;
                }
                else
                {
                    sum = "a=b";
                }
            }
        }

运行了盘发觉有点问题 修改后 OK了

[dalmeeme]

		string a = "1.0.22.1";
		string b = "1.0.3.8";
		string[] ss1 = a.Split('.');
		string[] ss2 = b.Split('.');
		for (int i = 0; i < ss1.Length; i++)
		{
			ss1[i] = ss1[i].PadLeft(3, '0');
			ss2[i] = ss2[i].PadLeft(3, '0');
		}
		string r1 = string.Concat(ss1);
		string r2 = string.Concat(ss2);
		Response.Write(r1.CompareTo(r2));

[wangjieest]

我倒觉得...对每个数直接 转化成相应的"足位数字".

例如
0001.0000.0000.0102
0001.0000.0000.0001
在进行字符串的比较

[linlianboy]

支持一个啊····又学会了

[rayyu1989]

http://msdn.microsoft.com/zh-cn/library/system.version(v=vs.90).aspx

string s1 ="001.001.002", s2 = "001.001.001";
Version v1 = new Version(s1), v2 = new Version(s2);
if (v1 > v2){
MessageBox.Show("Yes");
}

[色拉油]

按点截成字符数组，然后分别比较

[wanghui0380]

1.0.0.15 ???这不是软件发布版本号吗

如果是你不用操心了微软已经写好类了

System.Version
http://msdn.microsoft.com/zh-cn/library/system.version(v=vs.95).aspx

[蔡袅]

楼上几位说的点拆分都是Version内部源码的类似操作：

public int CompareTo(Version value)
{
	if (value == null)
	{
		return 1;
	}
	if (this._Major != value._Major)
	{
		if (this._Major > value._Major)
		{
			return 1;
		}
		return -1;
	}
	else
	{
		if (this._Minor != value._Minor)
		{
			if (this._Minor > value._Minor)
			{
				return 1;
			}
			return -1;
		}
		else
		{
			if (this._Build != value._Build)
			{
				if (this._Build > value._Build)
				{
					return 1;
				}
				return -1;
			}
			else
			{
				if (this._Revision == value._Revision)
				{
					return 0;
				}
				if (this._Revision > value._Revision)
				{
					return 1;
				}
				return -1;
			}
		}
	}
}

private int _Build = -1;
private int _Revision = -1;
/// <summary>
///               Initializes a new instance of the <see cref="T:System.Version" /> class using the specified string.
///           </summary>
/// <param name="version">
///               A string containing the major, minor, build, and revision numbers, where each number is delimited with a period character ('.'). 
///           </param>
/// <exception cref="T:System.ArgumentException">
///   <paramref name="version" /> has fewer than two components or more than four components. 
///           </exception>
/// <exception cref="T:System.ArgumentNullException">
///   <paramref name="version" /> is null. 
///           </exception>
/// <exception cref="T:System.ArgumentOutOfRangeException">
///               A major, minor, build, or revision component is less than zero. 
///           </exception>
/// <exception cref="T:System.FormatException">
///               At least one component of <paramref name="version" /> does not parse to an integer. 
///           </exception>
/// <exception cref="T:System.OverflowException">
///               At least one component of <paramref name="version" /> represents a number greater than <see cref="F:System.Int32.MaxValue" />.
///           </exception>
public Version(string version)
{
	if (version == null)
	{
		throw new ArgumentNullException("version");
	}
	string[] array = version.Split(new char[]
	{
		'.'
	});
	int num = array.Length;
	if (num < 2 || num > 4)
	{
		throw new ArgumentException(Environment.GetResourceString("Arg_VersionString"));
	}
	this._Major = int.Parse(array[0], CultureInfo.InvariantCulture);
	if (this._Major < 0)
	{
		throw new ArgumentOutOfRangeException("version", Environment.GetResourceString("ArgumentOutOfRange_Version"));
	}
	this._Minor = int.Parse(array[1], CultureInfo.InvariantCulture);
	if (this._Minor < 0)
	{
		throw new ArgumentOutOfRangeException("version", Environment.GetResourceString("ArgumentOutOfRange_Version"));
	}
	num -= 2;
	if (num > 0)
	{
		this._Build = int.Parse(array[2], CultureInfo.InvariantCulture);
		if (this._Build < 0)
		{
			throw new ArgumentOutOfRangeException("build", Environment.GetResourceString("ArgumentOutOfRange_Version"));
		}
		num--;
		if (num > 0)
		{
			this._Revision = int.Parse(array[3], CultureInfo.InvariantCulture);
			if (this._Revision < 0)
			{
				throw new ArgumentOutOfRangeException("revision", Environment.GetResourceString("ArgumentOutOfRange_Version"));
			}
		}
	}
}

[orochiheart]

原理的是从高位到低位的比较 高位的值谁大就决定最终是谁大

[whdrs]

高手呢

[whdrs]

lz 这不就是字符串的长度比较吗？我去呢，搞得那么神密

[wangxinlong_]

我也写了一个，字符串拆分成数组在进行比较时，感觉上面写的几个都不是很严谨，当两者长度不一样的时候会出现异常的，会有一个数组发生越界行为如1.0.0.1.2和1.0.0.1

 public int CompareString()
        {
            int num = 0;
            string str1 = "2.0.2.1";
            string str2 = "1.0.13.8";

            char[] char1 = str1.ToCharArray();
            char[] char2 = str2.ToCharArray();
            int i = char1.Length;
            int s = char2.Length;
            int length = 0;
            if (i > s)
            {
                length = s;
            }
            else
            {
                length = i;
            }
            for (int m = 0; m < length; m++)
            {
                if (char1[m] > char2[m])
                {
                    num = 1;//string str1大
                    break;
                }
                else if (char1[m] < char2[m])
                {
                    num = 2;//string str2大
                    break;
                }
            }
         
            return num;
        }

还有一种情况没有写出来，就是1.0.0.1.2和1.0.0.1的这种情况自己写吧！