blocks|key|330728|text|RFC只是试图说明带符号的整数是一个普通的4字节整数，其中的字节按big-endian方式排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|330729|现在，您很可能正在使用一台小端机器，BitConverter.GetBytes()将向您提供与之相反的byte[]。所以你可以试试：|offset|length|style|CODE|330730|int+intValue;
byte[]+intBytes+=+BitConverter.GetBytes(intValue);
Array.Reverse(intBytes);
byte[]+result+=+intBytes;|code-block|syntax|javascript|330731|但是，为了使代码具有最好的可移植性，您可以这样做：|330732|int+intValue;
byte[]+intBytes+=+BitConverter.GetBytes(intValue);
if+(BitConverter.IsLittleEndian)
++++Array.Reverse(intBytes);
byte[]+result+=+intBytes;|330733|entityMap^0|0|I|N|1F|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|Y|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

The RFC is just trying to say that a signed integer is a normal 4-byte integer with bytes ordered in a big-endian way.

Now, you are most probably working on a little-endian machine and <code>BitConverter.GetBytes()</code> will give you the <code>byte[]</code> reversed. So you could try:

<pre><code>int intValue;
byte[] intBytes = BitConverter.GetBytes(intValue);
Array.Reverse(intBytes);
byte[] result = intBytes;
</code></pre>

For the code to be most portable, however, you can do it like this:

<pre><code>int intValue;
byte[] intBytes = BitConverter.GetBytes(intValue);
if (BitConverter.IsLittleEndian)
 Array.Reverse(intBytes);
byte[] result = intBytes;
</code></pre>

blocks|key|3094471|text|BitConverter.GetBytes(int)几乎可以做你想做的事情，除了字节顺序是错误的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3094472|在使用BitConverter.GetBytes或使用Jon+Skeet的EndianBitConverter+class之前，可以使用IPAddress.HostToNetwork方法交换整数值中的字节。两种方法在可移植性方面都做了正确的事情(Tm)。|3094473|int+value;
byte[]+bytes+=+BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value));|code-block|syntax|javascript|3094474|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/217980/c-little-endian-or-big-endian/217993#217993|1|http://msdn.microsoft.com/en-us/library/653kcke1.aspx^0|0|Q|0|3|L|11|O|0|1W|N|1|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@$9|12|A|13|1|14]|$9|15|A|16|1|17]]|E|$]]|$1|H|3|I|5|J|7|18|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

<code>BitConverter.GetBytes(int)</code> almost does what you want, except the endianness is wrong.

You can use the <a href="http://msdn.microsoft.com/en-us/library/653kcke1.aspx" rel="noreferrer">IPAddress.HostToNetwork</a> method to swap the bytes within the the integer value before using <code>BitConverter.GetBytes</code> or use Jon Skeet's <a href="https://stackoverflow.com/questions/217980/c-little-endian-or-big-endian/217993#217993">EndianBitConverter class</a>. Both methods do the right thing(tm) regarding portability.

<pre><code>int value;
byte[] bytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(value));
</code></pre>

blocks|key|3094492|text|当我看到这篇描述时，我有一种感觉，这个xdr整数只是一个大端的“标准”整数，但它是以最模糊的方式表示的。Two's+complement+notation更为人所知的名称是U2，这也是我们在今天的处理器上使用的。字节顺序表明它是一个big-endian表示法。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3094493|因此，在回答您的问题时，您应该对数组中的元素进行反转(0+<-->+3，1+<-->2)，因为它们是以小端字节序编码的。为了确保这一点，您应该首先检查BitConverter.IsLittleEndian，看看您正在运行哪台机器。|style|CODE|3094494|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two's_complement|1|http://en.wikipedia.org/wiki/Endianness^0|1G|P|0|38|A|1|0|23|R|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@$A|Z|B|10|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

When I look at this description, I have a feeling, that this xdr integer is just a big-endian "standard" integer, but it's expressed in the most obfuscated way. <a href="http://en.wikipedia.org/wiki/Two&#39;s_complement" rel="nofollow noreferrer">Two's complement notation</a> is better know as U2, and it's what we are using on today's processors. The byte order indicates that it's a <a href="http://en.wikipedia.org/wiki/Endianness" rel="nofollow noreferrer">big-endian</a> notation. 
So, answering your question, you should inverse elements in your array (0 &lt;--> 3, 1 &lt;-->2), as they are encoded in little-endian. Just to make sure, you should first check <code>BitConverter.IsLittleEndian</code> to see on what machine you are running.

blocks|key|3307157|text|如果您想了解更多关于表示数字的各种方法的一般信息，请看一下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3307158|维基百科上的Two's+Complement和Signed+Number+Representation|offset|length|3307159|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two's_complement|1|http://en.wikipedia.org/wiki/Signed_number_representations^0|0|6|G|0|N|S|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

If you want more general information about various methods of representing numbers including Two's Complement have a look at:

<a href="http://en.wikipedia.org/wiki/Two&#39;s_complement" rel="nofollow noreferrer">Two's Complement</a> and <a href="http://en.wikipedia.org/wiki/Signed_number_representations" rel="nofollow noreferrer">Signed Number Representation</a> on Wikipedia

blocks|key|333606|text|这里有另一种方法:我们都知道1x字节=+8x位，而且，一个“常规”整数(int32)包含32位(4字节)。我们可以使用>>运算符将位向右移位(>>运算符不改变值)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|333607|int+intValue+=+566;

byte[]+bytes+=+new+byte[4];

bytes[0]+=+(byte)(intValue+>>+24);
bytes[1]+=+(byte)(intValue+>>+16);
bytes[2]+=+(byte)(intValue+>>+8);
bytes[3]+=+(byte)intValue;

Console.WriteLine("{0}+breaks+down+to+:+{1}+{2}+{3}+{4}",
++++intValue,+bytes[0],+bytes[1],+bytes[2],+bytes[3]);|code-block|syntax|javascript|333608|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's another way to do it: as we all know 1x byte = 8x bits and also, a "regular" integer (int32) contains 32 bits (4 bytes). We can use the >> operator to shift bits right (>> operator does not change value.)

<pre><code>int intValue = 566;

byte[] bytes = new byte[4];

bytes[0] = (byte)(intValue &gt;&gt; 24);
bytes[1] = (byte)(intValue &gt;&gt; 16);
bytes[2] = (byte)(intValue &gt;&gt; 8);
bytes[3] = (byte)intValue;

Console.WriteLine("{0} breaks down to : {1} {2} {3} {4}",
 intValue, bytes[0], bytes[1], bytes[2], bytes[3]);
</code></pre>

blocks|key|333610|text|byte[]+Take_Byte_Arr_From_Int(Int64+Source_Num)
{
+++Int64+Int64_Num+=+Source_Num;
+++byte+Byte_Num;
+++byte[]+Byte_Arr+=+new+byte[8];
+++for+(int+i+=+0;+i+<+8;+i%2B%2B)
+++{
++++++if+(Source_Num+>+255)
++++++{
+++++++++Int64_Num+=+Source_Num+/+256;
+++++++++Byte_Num+=+(byte)(Source_Num+-+Int64_Num+*+256);
++++++}
++++++else
++++++{
+++++++++Byte_Num+=+(byte)Int64_Num;
+++++++++Int64_Num+=+0;
++++++}
++++++Byte_Arr[i]+=+Byte_Num;
++++++Source_Num+=+Int64_Num;
+++}
+++return+(Byte_Arr);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|333611|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>byte[] Take_Byte_Arr_From_Int(Int64 Source_Num)
{
 Int64 Int64_Num = Source_Num;
 byte Byte_Num;
 byte[] Byte_Arr = new byte[8];
 for (int i = 0; i &lt; 8; i++)
 {
 if (Source_Num &gt; 255)
 {
 Int64_Num = Source_Num / 256;
 Byte_Num = (byte)(Source_Num - Int64_Num * 256);
 }
 else
 {
 Byte_Num = (byte)Int64_Num;
 Int64_Num = 0;
 }
 Byte_Arr[i] = Byte_Num;
 Source_Num = Int64_Num;
 }
 return (Byte_Arr);
}
</code></pre>

blocks|key|3094546|text|为什么上面示例中的所有这些代码...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3094547|具有显式布局的结构是双向的，不会对性能造成影响。|3094548|更新:由于有一个关于如何处理字节顺序的问题，我添加了一个接口来说明如何对其进行抽象。另一个实现结构可以处理相反的情况|3094549|public+interface+IIntToByte
{
++++Int32+Int+{+get;+set;}

++++byte+B0+{+get;+}
++++byte+B1+{+get;+}
++++byte+B2+{+get;+}
++++byte+B3+{+get;+}
}

[StructLayout(LayoutKind.Explicit)]
public+struct+IntToByteLE+:+UserQuery.IIntToByte
{
++++[FieldOffset(0)]
++++public+Int32+IntVal;

++++[FieldOffset(0)]
++++public+byte+b0;
++++[FieldOffset(1)]
++++public+byte+b1;
++++[FieldOffset(2)]
++++public+byte+b2;
++++[FieldOffset(3)]
++++public+byte+b3;

++++public+Int32+Int+{
++++++++get{+return+IntVal;+}
++++++++set{+IntVal+=+value;}
++++}

++++public+byte+B0+=>+b0;
++++public+byte+B1+=>+b1;
++++public+byte+B2+=>+b2;
++++public+byte+B3+=>+b3;+
}|code-block|syntax|javascript|3094550|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Why all this code in the samples above...

A struct with explicit layout acts both ways and has no performance hit.

Update: Since there's a question on how to deal with endianness I added an interface that illustrates how to abstract that. Another implementing struct can deal with the opposite case

<pre><code>public interface IIntToByte
{
 Int32 Int { get; set;}

 byte B0 { get; }
 byte B1 { get; }
 byte B2 { get; }
 byte B3 { get; }
}

[StructLayout(LayoutKind.Explicit)]
public struct IntToByteLE : UserQuery.IIntToByte
{
 [FieldOffset(0)]
 public Int32 IntVal;

 [FieldOffset(0)]
 public byte b0;
 [FieldOffset(1)]
 public byte b1;
 [FieldOffset(2)]
 public byte b2;
 [FieldOffset(3)]
 public byte b3;

 public Int32 Int {
 get{ return IntVal; }
 set{ IntVal = value;}
 }

 public byte B0 =&gt; b0;
 public byte B1 =&gt; b1;
 public byte B2 =&gt; b2;
 public byte B3 =&gt; b3; 
}
</code></pre>

blocks|key|335987|text|using+static+System.Console;

namespace+IntToBits
{
++++class+Program
++++{
++++++++static+void+Main()
++++++++{
++++++++++++while+(true)
++++++++++++{
++++++++++++++++string+s+=+Console.ReadLine();
++++++++++++++++Clear();
++++++++++++++++uint+i;
++++++++++++++++bool+b+=+UInt32.TryParse(s,+out+i);
++++++++++++++++if+(b)+IntPrinter(i);
++++++++++++}
++++++++}

++++++++static+void+IntPrinter(uint+i)
++++++++{
++++++++++++int[]+iarr+=+new+int+[32];
++++++++++++Write("[");
++++++++++++for+(int+j+=+0;+j+<+32;+j%2B%2B)
++++++++++++{
++++++++++++++++uint+tmp+=+i+&+(uint)Math.Pow(2,+j);

++++++++++++++++iarr[j]+=+(int)(tmp+>>+j);
++++++++++++}
++++++++++++for+(int+j+=+32;+j+>+0;+j--)
++++++++++++{
++++++++++++++++if(j%258==0+&&+j+!=+32)Write("%7C");
++++++++++++++++if(j%254==0+&&+j%258+!=0)+Write("'");
++++++++++++++++Write(iarr[j-1]);
++++++++++++}
++++++++++++WriteLine("]");
++++++++}
++++}
}```|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|335988|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>using static System.Console;

namespace IntToBits
{
 class Program
 {
 static void Main()
 {
 while (true)
 {
 string s = Console.ReadLine();
 Clear();
 uint i;
 bool b = UInt32.TryParse(s, out i);
 if (b) IntPrinter(i);
 }
 }

 static void IntPrinter(uint i)
 {
 int[] iarr = new int [32];
 Write("[");
 for (int j = 0; j &lt; 32; j++)
 {
 uint tmp = i &amp; (uint)Math.Pow(2, j);

 iarr[j] = (int)(tmp &gt;&gt; j);
 }
 for (int j = 32; j &gt; 0; j--)
 {
 if(j%8==0 &amp;&amp; j != 32)Write("|");
 if(j%4==0 &amp;&amp; j%8 !=0) Write("'");
 Write(iarr[j-1]);
 }
 WriteLine("]");
 }
 }
}```
</code></pre>

blocks|key|3094562|text|另一种方法是像这样使用BinaryPrimitives|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3094563|byte[]+intBytes+=+BitConverter.GetBytes(123);++int+actual+=+BinaryPrimitives.ReadInt32LittleEndian(intBytes);|style|CODE|3094564|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.microsoft.com/en-us/dotnet/api/system.buffers.binary.binaryprimitives?view=netcore-3.1^0|B|G|0|0|0|31|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@$A|U|B|V|F|G]]|9|@]|C|$]]|$1|H|3|-4|5|6|7|W|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

The other way is to use <a href="https://docs.microsoft.com/en-us/dotnet/api/system.buffers.binary.binaryprimitives?view=netcore-3.1" rel="noreferrer">BinaryPrimitives</a> like so

<code>byte[] intBytes = BitConverter.GetBytes(123);
 int actual = BinaryPrimitives.ReadInt32LittleEndian(intBytes);</code>

I need to convert an <code>int</code> to a <code>byte[]</code> one way of doing it is to use <code>BitConverter.GetBytes()</code>. But im unsure if that matches the following specification: 

<blockquote>
 An XDR signed integer is a 32-bit datum that encodes an integer in
 the range [-2147483648,2147483647]. The integer is represented in
 two's complement notation. The most and least significant bytes are
 0 and 3, respectively. Integers are declared as follows:
</blockquote>

Source: <code>RFC1014 3.2</code>

How could i do a int to byte transformation that would satisfy the above specification?

C# int to byte[]

我需要将int转换为byte[]，一种方法是使用BitConverter.GetBytes()。但我不确定这是否符合以下规范： XDR带符号整数是对-2147483648,2147483647范围内的整数进行编码的32位基准。整数以二的补码表示法表示。最高有效字节和最低有效字节分别为0和3。整数的声明如下：来源：RFC...

问到byte[]的C#整型
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问到byte[]的C#整型EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问到byte[]的C#整型
EN