如何在C#中以整数形式获取程序集版本？

我可以将其作为字符串获取：

Assembly.GetExecutingAssembly().GetName().Version()  

如何将此数字转换为整数

---

输入示例： 8.0.0.1

预期产出： 8001

---

您可以使用string.Split（'.'）、iterate和int.parse（）

它们都是数字，因此您可以将它们转换为字符串，然后依次堆叠：

Version v = Assembly.GetExecutingAssembly().GetName().Version;
string compacted = string.Format("{0}{1}{2}{3}", v.Major, v.Minor, v.Build, v.Revision);
int compactInt = int.Parse(compacted);

当然，这只在每个组件少于10个的情况下有效。之后，您无法确定实际版本是什么。字符串“12345”可以是1.23.4.5或12.3.4.5或1.2.34.5或

如果你知道它们都在10以下，你可以用数字表示：

Version v = Assembly.GetExecutingAssembly().GetName().Version;
int compactInt = v.Major * 1000 + v.Minor * 100 + v.Build * 10 + v.Revision;

如果您不知道这一点，它会变得有点复杂，但是您仍然可以在不创建字符串和解析它的情况下完成它。这可能会快一点，但需要10-20行代码。

以下“工作原理”：

string version = "8.0.0.1";
int versionNumber = int.Parse(version.Replace(".", ""));

但是，版本8.0.11.0和8.0.1.10之间没有区别

我会这样做：

Integer.Parse(Assembly.GetExecutingAssembly().GetName().Version().ToString().Replace(".", ""))

---

我的观点是正确的。

您还可能遇到这样的情况：程序集的版本为0.0.1.1，然后版本看起来像：11。绝对不是你想要的。

试试这个：

Version v = Assembly.GetExecutingAssembly().GetName().Version;
long s = long.Parse(v.Major.ToString("0000") + v.MajorRevision.ToString("0000") + v.Minor.ToString("0000") + v.MinorRevision.ToString("0000"));

---

你想解决的问题是什么？您是否正在检查某个库的运行版本是否大于或等于某个已知的无bug版本？如果是这样的话，正确的做法不是将以.-分隔的数字字符串视为单个数字，而是将它们分别与目标进行比较。

而不是采用这种方法，并且假设每个版本字符串元素小于255，则可以将每个元素作为32位无符号整数中的一个字节。这不是很容易让人理解的，但是可以确保如果版本比较中的V1如果您确实需要进行此转换，您至少应该为每个版本部分保留足够数量的数字

两位数字表示主要版本、次要版本和修订版本，四位数字表示构建版本：

var version = Assembly.GetExecutingAssembly().GetName().Version();

Debug.Assert(version.Major >= 0 && version.Major < 100)
Debug.Assert(version.Minor >= 0 && version.Minor < 100)
Debug.Assert(version.Build >= 0 && version.Build < 10000)
Debug.Assert(version.Revision >= 0 && version.Revision < 100)

long longVersion = version.Major * 100000000L + 
                   version.Minor * 1000000L + 
                   version.Build * 100L + 
                   version.Revision;

int intVersion  = (int) longVersion;

Debug.Assert((long)intVersion == longVersion)

var version=Assembly.getExecutionGassembly（）.GetName（）.version（）；
Debug.Assert（version.Major>=0&&version.Major<100）
Debug.Assert（version.Minor>=0&&version.Minor<100）
Debug.Assert（version.Build>=0&&version.Build<10000）
Debug.Assert（version.Revision>=0&&version.Revision<100）
long longVersion=版本。主要*100000000升+
版本.次要*100000ml+
版本.内部版本*100L+
版本.修订；
int-int版本=（int）longVersion；
Assert（（long）intVersion==longVersion）

请注意，对于某些外来版本，此方法仍将失败

甚至不要考虑版本21.47.4836.48:）

---

编辑：添加了断言。

另一个选项是将其视为4字节整数。对于每个版本部分（主要、次要、构建、修订），您将被限制为0-255的值，但您可以将版本打包为整数值

这可以防止8.10.0.0大于9.0.0.0（81000>9000）的问题

//
///  
///将版本字符串转换为的格式
///将[major].[minor].[build].[revision]转换为整数。
///  
/// 
/// 
///内部版本号的每个部分都必须在0到255之间。
/// 
///要转换为整数的版本。
/// 
///的整数表示形式。
/// 
公共静态整型整型整型整型（字符串版本）{
//解析版本号
var versionParts=version.Split（'.'）；
if（versionParts.Length！=4）{
抛出新的ArgumentException（“无效的版本号；无效的版本部分数，预期为4（主要.次要.构建.修订）”，
“版本”）；
}
//将部分转换为字节
字节主、次、构建、修订；
if（！byte.TryParse（versionParts[0]，out-major））{
抛出新ArgumentException（“无效版本号；无效主编号”，
“版本”）；
}
if（！byte.TryParse（versionParts[1]，out minor））{
抛出新ArgumentException（“无效版本号；无效次要编号”，
“版本”）；
}
if（！byte.TryParse（versionParts[2]，外部生成））{
抛出新ArgumentException（“版本号无效；内部版本号无效”，
“版本”）；
}
if（！byte.TryParse（versionParts[3]，out-revision））{
抛出新ArgumentException（“无效版本号；无效修订号”，
“版本”）；
}
//将字节合并为整数
var versionInteger=0；
versionInteger |=主要的第一步-你得到的字符串是什么？它实际上是一个多部分值。你应该看到类似于1.0.3.4的内容。它如何显示为整数是非常随意的。你必须问自己你想要主要版本还是次要版本？这就是我的想法，我打算引导提问者进入c结论想想8.1.11.0和8.11.1.0这两种情况，我刚刚意识到我需要在小调方面…我基本上需要将8.0.1.0转换为801000之类的东西？string version=“9.0.1.0”；int versionNumber=int.Parse（version+“0.0”。替换（“，”））；您不能将字符串强制转换为int。您必须解析它。int.parse或Convert.ToInt32可以做到这一点。您不能只去掉“.”字符，因为例如（正如AdamRalph和其他人指出的）从版本8.1.11.0和版本8.11.1.0中删除句点都将导致相同的整数值：81110+1用于拆分。这将使您可以根据需要格式化最终结果，因为您似乎特别关注最终整数的外观。在大多数情况下，生成是4位数字。在这种情况下，
    /// <summary>
    ///  
    /// Converts a version string in the format of 
    /// [major].[minor].[build].[revision] into an integer.
    ///  
    /// </summary>
    /// <remarks>
    /// Each part of the build number must be within the range of 0 to 255.
    /// </remarks>
    /// <param name="version"> The version to convert to an integer. </param>
    /// <returns>
    /// The integer representation of the <paramref name="version"/>.
    /// </returns>
    public static int VersionToInt( string version ) {
        // Parse version number
        var versionParts = version.Split( '.' );
        if ( versionParts.Length != 4 ) {
            throw new ArgumentException( "Invalid version number; invalid number of version parts, expected 4 (major.minor.build.revision)",
                                         "version" );
        }

        // Convert parts to bytes
        byte major, minor, build, revision;
        if ( !byte.TryParse( versionParts[0], out major ) ) {
            throw new ArgumentException( "Invalid version number; invalid major number", 
                                         "version" );
        }
        if ( !byte.TryParse( versionParts[1], out minor ) ) {
            throw new ArgumentException( "Invalid version number; invalid minor number",
                                         "version" );
        }
        if ( !byte.TryParse( versionParts[2], out build ) ) {
            throw new ArgumentException( "Invalid version number; invalid build number", 
                                         "version" );
        }
        if ( !byte.TryParse( versionParts[3], out revision ) ) {
            throw new ArgumentException( "Invalid version number; invalid revision number", 
                                         "version" );
        }

        // Combine bytes into an integer
        var versionInteger = 0;
        versionInteger |= major << 24;
        versionInteger |= minor << 16;
        versionInteger |= build << 8;
        versionInteger |= revision;

        return versionInteger;
    }

// assuming v is Version
var versionNumber = long.Parse(v.Major.ToString("x2") + v.Minor.ToString("x2") + v.Build.ToString("x2"), Globalization.NumberStyles.HexNumber);