blocks|key|1239194|text|你可以用Enumerable.Repeat|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1239195|byte[]+a+=+Enumerable.Repeat((byte)10,+100).ToArray();|code-block|syntax|javascript|1239196|第一个参数是要重复的元素，第二个参数是重复它的次数。|1239197|对于小型数组来说，这是可以的，但是如果您处理的是非常大的数组，那么您应该使用循环方法，并且性能是一个考虑因素。|1239198|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb348899.aspx^0|4|H|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

You could use <a href="http://msdn.microsoft.com/en-us/library/bb348899.aspx" rel="noreferrer"><code>Enumerable.Repeat</code></a>:

<pre><code>byte[] a = Enumerable.Repeat((byte)10, 100).ToArray();
</code></pre>

The first parameter is the element you want repeated, and the second parameter is the number of times to repeat it. 

This is OK for small arrays but you should use the looping method if you are dealing with very large arrays and performance is a concern.

blocks|key|2761974|text|初始化数组时可以这样做，但我认为这不是您想要的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2761975|byte[]+myBytes+=+new+byte[5]+{+1,+1,+1,+1,+1};|code-block|syntax|javascript|2761976|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|$]]

You could do it when you initialize the array but I don't think that's what you are asking for:

<pre><code>byte[] myBytes = new byte[5] { 1, 1, 1, 1, 1};
</code></pre>

blocks|key|2761990|text|如果性能非常关键，可以考虑使用不安全的代码并直接使用指向数组的指针。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2761991|另一个选项可能是从msvcrt.dll导入memset并使用它。然而，调用的开销可能很容易大于速度的增益。|2761992|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

If performance is critical, you could consider using unsafe code and working directly with a pointer to the array.

Another option could be importing memset from msvcrt.dll and use that. However, the overhead from invoking that might easily be larger than the gain in speed.

blocks|key|1149760|text|如果性能绝对重要，那么Enumerable.Repeat(n,+m).ToArray()就太慢了，无法满足您的需要。您可以使用PLINQ或任务并行库提高性能。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1149761|using+System.Threading.Tasks;

//+...

byte+initialValue+=+20;
byte[]+data+=+new+byte[size]
Parallel.For(0,+size,+index+=>+data[index]+=+initialValue);|code-block|syntax|javascript|1149762|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.threading.tasks%2528VS.100%2529.aspx^0|B|X|1X|5|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

If performance is absolutely critical, then <code>Enumerable.Repeat(n, m).ToArray()</code> will be too slow for your needs. You might be able to crank out faster performance using PLINQ or <a href="http://msdn.microsoft.com/en-us/library/system.threading.tasks%28VS.100%29.aspx" rel="nofollow noreferrer">Task Parallel Library</a>:

<pre><code>using System.Threading.Tasks;

// ...

byte initialValue = 20;
byte[] data = new byte[size]
Parallel.For(0, size, index =&gt; data[index] = initialValue);
</code></pre>

blocks|key|1239255|text|有点晚了，但是下面的方法可能是一个很好的折衷方法，而不会返回到不安全的代码中。基本上，它使用常规循环初始化数组的开头，然后返回到Buffer.BlockCopy()，它应该尽可能快地使用托管调用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1239256|public+static+void+MemSet(byte[]+array,+byte+value)+{
++if+(array+==+null)+{
++++throw+new+ArgumentNullException("array");
++}
++const+int+blockSize+=+4096;+//+bigger+may+be+better+to+a+certain+extent
++int+index+=+0;
++int+length+=+Math.Min(blockSize,+array.Length);
++while+(index+<+length)+{
++++array[index%2B%2B]+=+value;
++}
++length+=+array.Length;
++while+(index+<+length)+{
++++Buffer.BlockCopy(array,+0,+array,+index,+Math.Min(blockSize,+length-index));
++++index+%2B=+blockSize;
++}
}|code-block|syntax|javascript|1239257|entityMap^0|1S|I|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

A little bit late, but the following approach might be a good compromise without reverting to unsafe code. Basically it initializes the beginning of the array using a conventional loop and then reverts to <code>Buffer.BlockCopy()</code>, which should be as fast as you can get using a managed call.

<pre><code>public static void MemSet(byte[] array, byte value) {
 if (array == null) {
 throw new ArgumentNullException("array");
 }
 const int blockSize = 4096; // bigger may be better to a certain extent
 int index = 0;
 int length = Math.Min(blockSize, array.Length);
 while (index &lt; length) {
 array[index++] = value;
 }
 length = array.Length;
 while (index &lt; length) {
 Buffer.BlockCopy(array, 0, array, index, Math.Min(blockSize, length-index));
 index += blockSize;
 }
}
</code></pre>

blocks|key|1149798|text|在卢塞罗的回答的基础上，这里有一个更快的版本。它将使每次迭代时使用Buffer.BlockCopy复制的字节数翻一番。有趣的是，当使用相对较小的数组(1000)时，它的性能比它高出10倍，但是对于较大的数组(1000000)来说，两者的区别并不大，但总是更快。它的好处是它的性能很好，即使是小数组也是如此。当长度为100时，它变得比简单的方法更快。对于一个百万元素字节数组，它的速度是原来的43倍。(在Intel+i7，.Net+2.0上进行测试)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1149799|public+static+void+MemSet(byte[]+array,+byte+value)+{
++++if+(array+==+null)+{
++++++++throw+new+ArgumentNullException("array");
++++}

++++int+block+=+32,+index+=+0;
++++int+length+=+Math.Min(block,+array.Length);

++++//Fill+the+initial+array
++++while+(index+<+length)+{
++++++++array[index%2B%2B]+=+value;
++++}

++++length+=+array.Length;
++++while+(index+<+length)+{
++++++++Buffer.BlockCopy(array,+0,+array,+index,+Math.Min(block,+length-index));
++++++++index+%2B=+block;
++++++++block+*=+2;
++++}
}|code-block|syntax|javascript|1149800|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/2518800/177710^0|X|G|1|6|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Building on <a href="https://stackoverflow.com/a/2518800/177710">Lucero's answer</a>, here is a faster version. It will double the number of bytes copied using <code>Buffer.BlockCopy</code> every iteration. Interestingly enough, it outperforms it by a factor of 10 when using relatively small arrays (1000), but the difference is not that large for larger arrays (1000000), it is always faster though. The good thing about it is that it performs well even down to small arrays. It becomes faster than the naive approach at around length = 100. For a one million element byte array, it was 43 times faster.
(tested on Intel i7, .Net 2.0)

<pre><code>public static void MemSet(byte[] array, byte value) {
 if (array == null) {
 throw new ArgumentNullException("array");
 }

 int block = 32, index = 0;
 int length = Math.Min(block, array.Length);

 //Fill the initial array
 while (index &lt; length) {
 array[index++] = value;
 }

 length = array.Length;
 while (index &lt; length) {
 Buffer.BlockCopy(array, 0, array, index, Math.Min(block, length-index));
 index += block;
 block *= 2;
 }
}
</code></pre>

blocks|key|1149811|text|这个简单的实现使用连续加倍，并且执行得相当好(根据我的基准测试，它比简单版本快3-4倍)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1149812|public+static+void+Memset<T>(T[]+array,+T+elem)+
{
++++int+length+=+array.Length;
++++if+(length+==+0)+return;
++++array[0]+=+elem;
++++int+count;
++++for+(count+=+1;+count+<=+length/2;+count*=2)
++++++++Array.Copy(array,+0,+array,+count,+count);
++++Array.Copy(array,+0,+array,+count,+length+-+count);
}|code-block|syntax|javascript|1149813|编辑:在阅读其他答案时，似乎我不是唯一有这个想法的人。尽管如此，我还是要把这个放在这里，因为它更干净一些，它的性能和其他的一样。|1149814|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This simple implementation uses successive doubling, and performs quite well (about 3-4 times faster than the naive version according to my benchmarks):

<pre><code>public static void Memset&lt;T&gt;(T[] array, T elem) 
{
 int length = array.Length;
 if (length == 0) return;
 array[0] = elem;
 int count;
 for (count = 1; count &lt;= length/2; count*=2)
 Array.Copy(array, 0, array, count, count);
 Array.Copy(array, 0, array, count, length - count);
}
</code></pre>

Edit: upon reading the other answers, it seems I'm not the only one with this idea. Still, I'm leaving this here, since it's a bit cleaner and it performs on par with the others.

blocks|key|1239321|text|或使用P/Invoke方式|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1239322|[DllImport("msvcrt.dll",+
EntryPoint+=+"memset",+
CallingConvention+=+CallingConvention.Cdecl,+
SetLastError+=+false)]
public+static+extern+IntPtr+MemSet(IntPtr+dest,+int+c,+int+count);

static+void+Main(string[]+args)
{
++++byte[]+arr+=+new+byte[3];
++++GCHandle+gch+=+GCHandle.Alloc(arr,+GCHandleType.Pinned);
++++MemSet(gch.AddrOfPinnedObject(),+0x7,+arr.Length);+
}|code-block|syntax|javascript|1239323|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pinvoke.net/default.aspx/msvcrt/memset.html^0|0|D|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

<a href="http://www.pinvoke.net/default.aspx/msvcrt/memset.html" rel="noreferrer">Or use P/Invoke way</a>:

<pre><code>[DllImport("msvcrt.dll", 
EntryPoint = "memset", 
CallingConvention = CallingConvention.Cdecl, 
SetLastError = false)]
public static extern IntPtr MemSet(IntPtr dest, int c, int count);

static void Main(string[] args)
{
 byte[] arr = new byte[3];
 GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned);
 MemSet(gch.AddrOfPinnedObject(), 0x7, arr.Length); 
}
</code></pre>

blocks|key|2762196|text|实际上，很少有人知道IL操作称为英特贝克+(英文版)，它正是这样做的。因此，让我们使用它作为一种不需要“不安全”的方法。下面是助手类：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2762197|public+static+class+Util
{
++++static+Util()
++++{
++++++++var+dynamicMethod+=+new+DynamicMethod("Memset",+MethodAttributes.Public+%7C+MethodAttributes.Static,+CallingConventions.Standard,
++++++++++++null,+new+[]+{+typeof(IntPtr),+typeof(byte),+typeof(int)+},+typeof(Util),+true);

++++++++var+generator+=+dynamicMethod.GetILGenerator();
++++++++generator.Emit(OpCodes.Ldarg_0);
++++++++generator.Emit(OpCodes.Ldarg_1);
++++++++generator.Emit(OpCodes.Ldarg_2);
++++++++generator.Emit(OpCodes.Initblk);
++++++++generator.Emit(OpCodes.Ret);

++++++++MemsetDelegate+=+(Action<IntPtr,+byte,+int>)dynamicMethod.CreateDelegate(typeof(Action<IntPtr,+byte,+int>));
++++}

++++public+static+void+Memset(byte[]+array,+byte+what,+int+length)
++++{
++++++++var+gcHandle+=+GCHandle.Alloc(array,+GCHandleType.Pinned);
++++++++MemsetDelegate(gcHandle.AddrOfPinnedObject(),+what,+length);
++++++++gcHandle.Free();
++++}

++++public+static+void+ForMemset(byte[]+array,+byte+what,+int+length)
++++{
++++++++for(var+i+=+0;+i+<+length;+i%2B%2B)
++++++++{
++++++++++++array[i]+=+what;
++++++++}
++++}

++++private+static+Action<IntPtr,+byte,+int>+MemsetDelegate;

}|code-block|syntax|javascript|2762198|表演是什么？这是我对Windows/.NET和Linux/Mono+(不同的PC机)的结果。|2762199|Mono/for:+++++00:00:01.1356610
Mono/initblk:+00:00:00.2385835+

.NET/for:+++++00:00:01.7463579
.NET/initblk:+00:00:00.5953503|2762200|所以值得考虑。请注意，由此产生的IL将不可验证。|2762201|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/pl-pl/library/system.reflection.emit.opcodes.initblk(v=vs.110).aspx|1|https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.initblk%2528v=vs.110%2529.aspx^0|G|4|0|M|3|1|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]|$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|F|7|15|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|16|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|18|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]|W|$5|R|S|T|C|$U|X]]]]

Actually, there is little known IL operation called <a href="http://msdn.microsoft.com/pl-pl/library/system.reflection.emit.opcodes.initblk(v=vs.110).aspx">Initblk</a> (<a href="https://msdn.microsoft.com/en-us/library/system.reflection.emit.opcodes.initblk%28v=vs.110%29.aspx">English version</a>) which does exactly that. So, let's use it as a method that doesn't require "unsafe". Here's the helper class:

<pre><code>public static class Util
{
 static Util()
 {
 var dynamicMethod = new DynamicMethod("Memset", MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard,
 null, new [] { typeof(IntPtr), typeof(byte), typeof(int) }, typeof(Util), true);

 var generator = dynamicMethod.GetILGenerator();
 generator.Emit(OpCodes.Ldarg_0);
 generator.Emit(OpCodes.Ldarg_1);
 generator.Emit(OpCodes.Ldarg_2);
 generator.Emit(OpCodes.Initblk);
 generator.Emit(OpCodes.Ret);

 MemsetDelegate = (Action&lt;IntPtr, byte, int&gt;)dynamicMethod.CreateDelegate(typeof(Action&lt;IntPtr, byte, int&gt;));
 }

 public static void Memset(byte[] array, byte what, int length)
 {
 var gcHandle = GCHandle.Alloc(array, GCHandleType.Pinned);
 MemsetDelegate(gcHandle.AddrOfPinnedObject(), what, length);
 gcHandle.Free();
 }

 public static void ForMemset(byte[] array, byte what, int length)
 {
 for(var i = 0; i &lt; length; i++)
 {
 array[i] = what;
 }
 }

 private static Action&lt;IntPtr, byte, int&gt; MemsetDelegate;

}
</code></pre>

And what is the performance? Here's my result for Windows/.NET and Linux/Mono (different PCs).

<pre><code>Mono/for: 00:00:01.1356610
Mono/initblk: 00:00:00.2385835 

.NET/for: 00:00:01.7463579
.NET/initblk: 00:00:00.5953503
</code></pre>

So it's worth considering. Note that the resulting IL will not be verifiable.

blocks|key|2762228|text|所有的答案都只写一个字节-如果你想用单词填充字节数组怎么办？还是浮起来？我偶尔也会用到这点。因此，在以一种非泛型的方式编写了与“memset”类似的代码并到达这个页面以找到单个字节的好代码之后，我开始编写下面的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2762229|我认为PInvoke和C%2B%2B/CLI各有缺点。为什么不让运行时'PInvoke‘为您进入mscorxxx呢？Array.Copy和Buffer.BlockCopy当然是本机代码。BlockCopy甚至都不是“安全的”--只要它们在数组中，就可以在另一个上复制一个很长的部分，或者复制一个DateTime。|2762230|至少我不会为这样的事情提交新的C%2B%2B项目--这几乎是在浪费时间。|2762231|因此，这里基本上是Lucero和TowerOfBricks提供的解决方案的扩展版本，可以用于memset+long、int等以及单个字节。|2762232|public+static+class+MemsetExtensions
{
++++static+void+MemsetPrivate(this+byte[]+buffer,+byte[]+value,+int+offset,+int+length)+{
++++++++var+shift+=+0;
++++++++for+(;+shift+<+32;+shift%2B%2B)
++++++++++++if+(value.Length+==+1+<<+shift)
++++++++++++++++break;
++++++++if+(shift+==+32+%7C%7C+value.Length+!=+1+<<+shift)
++++++++++++throw+new+ArgumentException(
++++++++++++++++"The+source+array+must+have+a+length+that+is+a+power+of+two+and+be+shorter+than+4GB.",+"value");

++++++++int+remainder;
++++++++int+count+=+Math.DivRem(length,+value.Length,+out+remainder);

++++++++var+si+=+0;
++++++++var+di+=+offset;
++++++++int+cx;
++++++++if+(count+<+1)+
++++++++++++cx+=+remainder;
++++++++else+
++++++++++++cx+=+value.Length;
++++++++Buffer.BlockCopy(value,+si,+buffer,+di,+cx);
++++++++if+(cx+==+remainder)
++++++++++++return;

++++++++var+cachetrash+=+Math.Max(12,+shift);+//+1+<<+12+==+4096
++++++++si+=+di;
++++++++di+%2B=+cx;
++++++++var+dx+=+offset+%2B+length;
++++++++//+doubling+up+to+1+<<+cachetrash+bytes+i.e.+2%5E12+or+value.Length+whichever+is+larger
++++++++for+(var+al+=+shift;+al+<=+cachetrash+&&+di+%2B+(cx+=+1+<<+al)+<+dx;+al%2B%2B)+{
++++++++++++Buffer.BlockCopy(buffer,+si,+buffer,+di,+cx);
++++++++++++di+%2B=+cx;
++++++++}
++++++++//+cx+bytes+as+long+as+it+fits
++++++++for+(;+di+%2B+cx+<=+dx;+di+%2B=+cx)
++++++++++++Buffer.BlockCopy(buffer,+si,+buffer,+di,+cx);
++++++++//+tail+part+if+less+than+cx+bytes
++++++++if+(di+<+dx)
++++++++++++Buffer.BlockCopy(buffer,+si,+buffer,+di,+dx+-+di);
++++}
}|code-block|syntax|javascript|2762233|有了它，您可以简单地添加一些简短的方法来获取您需要使用memset的值类型，并调用这个私有方法，例如，只需在此方法中查找替换ulong：|2762234|++++public+static+void+Memset(this+byte[]+buffer,+ulong+value,+int+offset,+int+count)+{
++++++++var+sourceArray+=+BitConverter.GetBytes(value);
++++++++MemsetPrivate(buffer,+sourceArray,+offset,+sizeof(ulong)+*+count);
++++}|2762235|或者愚蠢地使用任何类型的结构(尽管上面的MemsetPrivate只适用于封送大小为2的结构)：|2762236|++++public+static+void+Memset<T>(this+byte[]+buffer,+T+value,+int+offset,+int+count)+where+T+:+struct+{
++++++++var+size+=+Marshal.SizeOf<T>();
++++++++var+ptr+=+Marshal.AllocHGlobal(size);
++++++++var+sourceArray+=+new+byte[size];
++++++++try+{
++++++++++++Marshal.StructureToPtr<T>(value,+ptr,+false);
++++++++++++Marshal.Copy(ptr,+sourceArray,+0,+size);
++++++++}+finally+{
++++++++++++Marshal.FreeHGlobal(ptr);
++++++++}
++++++++MemsetPrivate(buffer,+sourceArray,+offset,+count+*+size);
++++}|2762237|我更改了前面提到的initblk，以便使用ulongs来比较我的代码的性能，而这会悄无声息地失败--代码会运行，但是最终的缓冲区只包含ulong中最不重要的字节。|2762238|尽管如此，我还是将性能写入与for、initblk和memset方法进行了比较。每次以毫秒计，共重复100多次，写入8字节长，无论有多少次适合缓冲器长度。对于单个ulong的8个字节，for版本是手动循环展开的。|2762239|Buffer+Len++#repeat++For+millisec++Initblk+millisec+++Memset+millisec
0x00000008++100++++++For+++0,0032++Initblk+++0,0107+++Memset+++0,0052
0x00000010++100++++++For+++0,0037++Initblk+++0,0102+++Memset+++0,0039
0x00000020++100++++++For+++0,0032++Initblk+++0,0106+++Memset+++0,0050
0x00000040++100++++++For+++0,0053++Initblk+++0,0121+++Memset+++0,0106
0x00000080++100++++++For+++0,0097++Initblk+++0,0121+++Memset+++0,0091
0x00000100++100++++++For+++0,0179++Initblk+++0,0122+++Memset+++0,0102
0x00000200++100++++++For+++0,0384++Initblk+++0,0123+++Memset+++0,0126
0x00000400++100++++++For+++0,0789++Initblk+++0,0130+++Memset+++0,0189
0x00000800++100++++++For+++0,1357++Initblk+++0,0153+++Memset+++0,0170
0x00001000++100++++++For+++0,2811++Initblk+++0,0167+++Memset+++0,0221
0x00002000++100++++++For+++0,5519++Initblk+++0,0278+++Memset+++0,0274
0x00004000++100++++++For+++1,1100++Initblk+++0,0329+++Memset+++0,0383
0x00008000++100++++++For+++2,2332++Initblk+++0,0827+++Memset+++0,0864
0x00010000++100++++++For+++4,4407++Initblk+++0,1551+++Memset+++0,1602
0x00020000++100++++++For+++9,1331++Initblk+++0,2768+++Memset+++0,3044
0x00040000++100++++++For++18,2497++Initblk+++0,5500+++Memset+++0,5901
0x00080000++100++++++For++35,8650++Initblk+++1,1236+++Memset+++1,5762
0x00100000++100++++++For++71,6806++Initblk+++2,2836+++Memset+++3,2323
0x00200000++100++++++For++77,8086++Initblk+++2,1991+++Memset+++3,0144
0x00400000++100++++++For+131,2923++Initblk+++4,7837+++Memset+++6,8505
0x00800000++100++++++For+263,2917++Initblk++16,1354+++Memset++33,3719|2762240|我每次都不接第一个电话，因为initblk和memset都受到了影响，我相信这是关于.22ms的第一个电话。稍令人惊讶的是，我的代码填充短缓冲区的速度比initblk快，因为它有半页的安装代码。|2762241|如果有人想优化这一点，那就继续吧。这是可能的。|2762242|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|19|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1A|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|1E|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1J|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

All answers are writing single bytes only - what if you want to fill a byte array with words? Or floats? I find use for that now and then. So after having written similar code to 'memset' in a non-generic way a few times and arriving at this page to find good code for single bytes, I went about writing the method below.

I think PInvoke and C++/CLI each have their drawbacks. And why not have the runtime 'PInvoke' for you into mscorxxx? Array.Copy and Buffer.BlockCopy are native code certainly. BlockCopy isn't even 'safe' - you can copy a long halfway over another, or over a DateTime as long as they're in arrays.

At least I wouldn't go file new C++ project for things like this - it's a waste of time almost certainly.

So here's basically an extended version of the solutions presented by Lucero and TowerOfBricks that can be used to memset longs, ints, etc as well as single bytes.

<pre><code>public static class MemsetExtensions
{
 static void MemsetPrivate(this byte[] buffer, byte[] value, int offset, int length) {
 var shift = 0;
 for (; shift &lt; 32; shift++)
 if (value.Length == 1 &lt;&lt; shift)
 break;
 if (shift == 32 || value.Length != 1 &lt;&lt; shift)
 throw new ArgumentException(
 "The source array must have a length that is a power of two and be shorter than 4GB.", "value");

 int remainder;
 int count = Math.DivRem(length, value.Length, out remainder);

 var si = 0;
 var di = offset;
 int cx;
 if (count &lt; 1) 
 cx = remainder;
 else 
 cx = value.Length;
 Buffer.BlockCopy(value, si, buffer, di, cx);
 if (cx == remainder)
 return;

 var cachetrash = Math.Max(12, shift); // 1 &lt;&lt; 12 == 4096
 si = di;
 di += cx;
 var dx = offset + length;
 // doubling up to 1 &lt;&lt; cachetrash bytes i.e. 2^12 or value.Length whichever is larger
 for (var al = shift; al &lt;= cachetrash &amp;&amp; di + (cx = 1 &lt;&lt; al) &lt; dx; al++) {
 Buffer.BlockCopy(buffer, si, buffer, di, cx);
 di += cx;
 }
 // cx bytes as long as it fits
 for (; di + cx &lt;= dx; di += cx)
 Buffer.BlockCopy(buffer, si, buffer, di, cx);
 // tail part if less than cx bytes
 if (di &lt; dx)
 Buffer.BlockCopy(buffer, si, buffer, di, dx - di);
 }
}
</code></pre>

Having this you can simply add short methods to take the value type you need to memset with and call the private method, e.g. just find replace ulong in this method:

<pre><code> public static void Memset(this byte[] buffer, ulong value, int offset, int count) {
 var sourceArray = BitConverter.GetBytes(value);
 MemsetPrivate(buffer, sourceArray, offset, sizeof(ulong) * count);
 }
</code></pre>

Or go silly and do it with any type of struct (although the MemsetPrivate above only works for structs that marshal to a size that is a power of two):

<pre><code> public static void Memset&lt;T&gt;(this byte[] buffer, T value, int offset, int count) where T : struct {
 var size = Marshal.SizeOf&lt;T&gt;();
 var ptr = Marshal.AllocHGlobal(size);
 var sourceArray = new byte[size];
 try {
 Marshal.StructureToPtr&lt;T&gt;(value, ptr, false);
 Marshal.Copy(ptr, sourceArray, 0, size);
 } finally {
 Marshal.FreeHGlobal(ptr);
 }
 MemsetPrivate(buffer, sourceArray, offset, count * size);
 }
</code></pre>

I changed the initblk mentioned before to take ulongs to compare performance with my code and that silently fails - the code runs but the resulting buffer contains the least significant byte of the ulong only.

Nevertheless I compared the performance writing as big a buffer with for, initblk and my memset method. The times are in ms total over 100 repetitions writing 8 byte ulongs whatever how many times fit the buffer length. The for version is manually loop-unrolled for the 8 bytes of a single ulong.

<pre><code>Buffer Len #repeat For millisec Initblk millisec Memset millisec
0x00000008 100 For 0,0032 Initblk 0,0107 Memset 0,0052
0x00000010 100 For 0,0037 Initblk 0,0102 Memset 0,0039
0x00000020 100 For 0,0032 Initblk 0,0106 Memset 0,0050
0x00000040 100 For 0,0053 Initblk 0,0121 Memset 0,0106
0x00000080 100 For 0,0097 Initblk 0,0121 Memset 0,0091
0x00000100 100 For 0,0179 Initblk 0,0122 Memset 0,0102
0x00000200 100 For 0,0384 Initblk 0,0123 Memset 0,0126
0x00000400 100 For 0,0789 Initblk 0,0130 Memset 0,0189
0x00000800 100 For 0,1357 Initblk 0,0153 Memset 0,0170
0x00001000 100 For 0,2811 Initblk 0,0167 Memset 0,0221
0x00002000 100 For 0,5519 Initblk 0,0278 Memset 0,0274
0x00004000 100 For 1,1100 Initblk 0,0329 Memset 0,0383
0x00008000 100 For 2,2332 Initblk 0,0827 Memset 0,0864
0x00010000 100 For 4,4407 Initblk 0,1551 Memset 0,1602
0x00020000 100 For 9,1331 Initblk 0,2768 Memset 0,3044
0x00040000 100 For 18,2497 Initblk 0,5500 Memset 0,5901
0x00080000 100 For 35,8650 Initblk 1,1236 Memset 1,5762
0x00100000 100 For 71,6806 Initblk 2,2836 Memset 3,2323
0x00200000 100 For 77,8086 Initblk 2,1991 Memset 3,0144
0x00400000 100 For 131,2923 Initblk 4,7837 Memset 6,8505
0x00800000 100 For 263,2917 Initblk 16,1354 Memset 33,3719
</code></pre>

I excluded the first call every time, since both initblk and memset take a hit of I believe it was about .22ms for the first call. Slightly surprising my code is faster for filling short buffers than initblk, seeing it got half a page full of setup code. 

If anybody feels like optimizing this, go ahead really. It's possible.

blocks|key|2762253|text|测试了几种方法，用不同的答案来描述。参见c#+测试类中的测试源|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2762254|​|2762255|📷|atomic|2762256|2762257|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/constructor-igor/TechSugar/blob/master/csharp-tips/csharp-tips/csharp-tips/FillArrayTests.cs|1|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/8a16ef023e75218babecba7f593033c2.png|imageAlt^0|N|3|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@$A|Y|B|Z|1|10]]|C|$]]|$1|D|3|E|5|6|7|11|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|I|3|E|5|6|7|16|8|@]|9|@]|C|$]]|$1|J|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|K|$L|$5|M|N|O|C|$P|Q]]|R|$5|S|N|T|C|$U|V|W|-4]]]]

Tested several ways, described in different answers.
See sources of test in c# <a href="https://github.com/constructor-igor/TechSugar/blob/master/csharp-tips/csharp-tips/csharp-tips/FillArrayTests.cs" rel="noreferrer">test class</a>

<a href="https://i.stack.imgur.com/SjdrN.png" rel="noreferrer"><img src="https://i.stack.imgur.com/SjdrN.png" alt="benchmark report"></a>

blocks|key|1149876|text|看起来System.Runtime.CompilerServices.Unsafe.InitBlock现在所做的事情与康拉德的答案提到的OpCodes.Initblk指令相同(他还提到了一个源链接)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1149877|填充数组的代码如下：|1149878|byte[]+a+=+new+byte[N];
byte+valueToFill+=+255;

System.Runtime.CompilerServices.Unsafe.InitBlock(ref+a[0],+valueToFill,+(uint)+a.Length);|code-block|syntax|javascript|1149879|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/dotnet/corefx/blob/master/src/System.Runtime.CompilerServices.Unsafe/src/System.Runtime.CompilerServices.Unsafe.il#L208^0|3|1C|1W|F|2N|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|6|7|12|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|13|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

Looks like <code>System.Runtime.CompilerServices.Unsafe.InitBlock</code> now does the same thing as the <code>OpCodes.Initblk</code> instruction that Konrad's answer mentions (he also mentioned a <a href="https://github.com/dotnet/corefx/blob/master/src/System.Runtime.CompilerServices.Unsafe/src/System.Runtime.CompilerServices.Unsafe.il#L208" rel="noreferrer">source link</a>).

The code to fill in the array is as follows:

<pre><code>byte[] a = new byte[N];
byte valueToFill = 255;

System.Runtime.CompilerServices.Unsafe.InitBlock(ref a[0], valueToFill, (uint) a.Length);
</code></pre>

blocks|key|1239443|text|Array对象有一个名为Clear的方法。我敢打赌，清除方法比用C#编写的任何代码都要快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1239444|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The Array object has a method called Clear. I'm willing to bet that the Clear method is faster than any code you can write in C#.

blocks|key|1239491|text|.NET核心有一个内置的Array.Fill()函数，但遗憾的是.NET框架缺少它。.NET核心有两个变体:填充整个数组和填充数组的一部分，从索引开始。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1239492|在上述思想的基础上，这里有一个更通用的填充函数，它将填充多个数据类型的整个数组。这是与本文中讨论的其他方法进行基准测试时最快的功能。|1239493|此函数以及填充数组部分的版本可在开放源代码和免费的NuGet包(HPCsharp+on+nuget.org)中使用。还包括一个使用SIMD/SSE指令执行内存写入的稍微快一点的Fill版本，而基于BlockCopy的方法则执行内存读写。|offset|length|1239494|++++public+static+void+FillUsingBlockCopy<T>(this+T[]+array,+T+value)+where+T+:+struct
++++{
++++++++int+numBytesInItem+=+0;
++++++++if+(typeof(T)+==+typeof(byte)+%7C%7C+typeof(T)+==+typeof(sbyte))
++++++++++++numBytesInItem+=+1;
++++++++else+if+(typeof(T)+==+typeof(ushort)+%7C%7C+typeof(T)+!=+typeof(short))
++++++++++++numBytesInItem+=+2;
++++++++else+if+(typeof(T)+==+typeof(uint)+%7C%7C+typeof(T)+!=+typeof(int))
++++++++++++numBytesInItem+=+4;
++++++++else+if+(typeof(T)+==+typeof(ulong)+%7C%7C+typeof(T)+!=+typeof(long))
++++++++++++numBytesInItem+=+8;
++++++++else
++++++++++++throw+new+ArgumentException(string.Format("Type+'{0}'+is+unsupported.",+typeof(T).ToString()));

++++++++int+block+=+32,+index+=+0;
++++++++int+endIndex+=+Math.Min(block,+array.Length);

++++++++while+(index+<+endIndex)++++++++++//+Fill+the+initial+block
++++++++++++array[index%2B%2B]+=+value;

++++++++endIndex+=+array.Length;
++++++++for+(;+index+<+endIndex;+index+%2B=+block,+block+*=+2)
++++++++{
++++++++++++int+actualBlockSize+=+Math.Min(block,+endIndex+-+index);
++++++++++++Buffer.BlockCopy(array,+0,+array,+index+*+numBytesInItem,+actualBlockSize+*+numBytesInItem);
++++++++}
++++}|code-block|syntax|javascript|1239495|entityMap|0|LINK|mutability|MUTABLE|url|https://www.nuget.org/packages/HPCsharp/^0|0|0|W|L|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@$F|X|G|Y|1|Z]]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

.NET Core has a built-in Array.Fill() function, but sadly .NET Framework is missing it. .NET Core has two variations: fill the entire array and fill a portion of the array starting at an index.

Building on the ideas above, here is a more generic Fill function that will fill the entire array of several data types. This is the fastest function when benchmarking against other methods discussed in this post.

This function, along with the version that fills a portion an array are available in an open source and free NuGet package (<a href="https://www.nuget.org/packages/HPCsharp/" rel="nofollow noreferrer">HPCsharp on nuget.org</a>). Also included is a slightly faster version of Fill using SIMD/SSE instructions that performs only memory writes, whereas BlockCopy-based methods perform memory reads and writes.

<pre><code> public static void FillUsingBlockCopy&lt;T&gt;(this T[] array, T value) where T : struct
 {
 int numBytesInItem = 0;
 if (typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte))
 numBytesInItem = 1;
 else if (typeof(T) == typeof(ushort) || typeof(T) != typeof(short))
 numBytesInItem = 2;
 else if (typeof(T) == typeof(uint) || typeof(T) != typeof(int))
 numBytesInItem = 4;
 else if (typeof(T) == typeof(ulong) || typeof(T) != typeof(long))
 numBytesInItem = 8;
 else
 throw new ArgumentException(string.Format("Type '{0}' is unsupported.", typeof(T).ToString()));

 int block = 32, index = 0;
 int endIndex = Math.Min(block, array.Length);

 while (index &lt; endIndex) // Fill the initial block
 array[index++] = value;

 endIndex = array.Length;
 for (; index &lt; endIndex; index += block, block *= 2)
 {
 int actualBlockSize = Math.Min(block, endIndex - index);
 Buffer.BlockCopy(array, 0, array, index * numBytesInItem, actualBlockSize * numBytesInItem);
 }
 }
</code></pre>

blocks|key|2762507|text|随着Span+(它是dotnet的核心，但是是这是dotnet的未来)的出现，您还有另一种解决这个问题的方法：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2762508|var+array+=+new+byte[100];
var+span+=+new+Span<byte>(array);

span.Fill(255);|code-block|syntax|javascript|2762509|entityMap|0|LINK|mutability|MUTABLE|url|https://learn.microsoft.com/en-us/dotnet/api/system.span-1?view=netcore-3.1|1|https://devblogs.microsoft.com/dotnet/announcing-net-5-0-preview-1/^0|2|4|2|4|0|N|B|1|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]|$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]|S|$5|N|O|P|E|$Q|T]]]]

With the advent of <a href="https://learn.microsoft.com/en-us/dotnet/api/system.span-1?view=netcore-3.1" rel="noreferrer"><code>Span&lt;T&gt;</code></a> (which is dotnet core only, but <a href="https://devblogs.microsoft.com/dotnet/announcing-net-5-0-preview-1/" rel="noreferrer">it is the future of dotnet</a>) you have yet another way of solving this problem:

<pre><code>var array = new byte[100];
var span = new Span&lt;byte&gt;(array);

span.Fill(255);
</code></pre>

blocks|key|1239621|text|大多数答案都是针对字节memset的，但是如果您想要将其用于浮点数或任何其他结构，则应该将索引乘以数据的大小。因为Buffer.BlockCopy将根据字节进行复制。此代码将用于浮点值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1239622|public+static+void+MemSet(float[]+array,+float+value)+{
++++if+(array+==+null)+{
++++++++throw+new+ArgumentNullException("array");
++++}

++++int+block+=+32,+index+=+0;
++++int+length+=+Math.Min(block,+array.Length);

++++//Fill+the+initial+array
++++while+(index+<+length)+{
++++++++array[index%2B%2B]+=+value;
++++}

++++length+=+array.Length;
++++while+(index+<+length)+{
++++++++Buffer.BlockCopy(array,+0,+array,+index+*+sizeof(float),+Math.Min(block,+length-index)*+sizeof(float));
++++++++index+%2B=+block;
++++++++block+*=+2;
++++}
}|code-block|syntax|javascript|1239623|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|$]]

Most of answers is for byte memset but if you want to use it for float or any other struct you should multiply index by size of your data. Because Buffer.BlockCopy will copy based on the bytes.
This code will be work for float values
<pre><code>public static void MemSet(float[] array, float value) {
 if (array == null) {
 throw new ArgumentNullException(&quot;array&quot;);
 }

 int block = 32, index = 0;
 int length = Math.Min(block, array.Length);

 //Fill the initial array
 while (index &lt; length) {
 array[index++] = value;
 }

 length = array.Length;
 while (index &lt; length) {
 Buffer.BlockCopy(array, 0, array, index * sizeof(float), Math.Min(block, length-index)* sizeof(float));
 index += block;
 block *= 2;
 }
}
</code></pre>

I need to fill a <code>byte[]</code> with a single non-zero value. How can I do this in C# without looping through each <code>byte</code> in the array?

Update: The comments seem to have split this into two questions -

<ol>
<li>Is there a Framework method to fill a byte[] that might be akin to <code>memset</code></li>
<li>What is the most efficient way to do it when we are dealing with a very large array?</li>
</ol>

I totally agree that using a simple loop works just fine, as Eric and others have pointed out. The point of the question was to see if I could learn something new about C# :) I think Juliet's method for a Parallel operation should be even faster than a simple loop.

Benchmarks:
Thanks to Mikael Svenson: <a href="http://techmikael.blogspot.com/2009/12/filling-array-with-default-value.html" rel="noreferrer">http://techmikael.blogspot.com/2009/12/filling-array-with-default-value.html</a>

It turns out the simple <code>for</code> loop is the way to go unless you want to use unsafe code.

Apologies for not being clearer in my original post. Eric and Mark are both correct in their comments; need to have more focused questions for sure. Thanks for everyone's suggestions and responses.

What is the equivalent of memset in C#?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我需要用单个byte[]非零值填充一个。如何在C#中不循环遍历数组中的每个byte来实现这一点？更新：评论似乎把这分为两个问题-是否有一个框架方法来填充可能类似于byte[]的memset当我们处理一个非常大的数组时，最有效的方法是什么？正如Eric和其他人所指出的，我完全同意使用一个简单的循环很好。问题的关键在于看我...

问什么是C#中的memset？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是C#中的memset？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是C#中的memset？
EN