Copy

FrameworkFork\Microsoft.Xml\Xml\BinaryXml\XmlBinaryReader.cs (8)

1913System.Array.Copy(symtable, 0, n, 0, symNum); 1929System.Array.Copy(qnametable, 0, n, 0, qnameNum); 2022System.Array.Copy(data, mark, newdata, 0, cbKeep); 2027System.Array.Copy(data, mark, data, 0, cbKeep); 2434System.Array.Copy(_elementStack, 0, n, 0, _elementStack.Length); 2443System.Array.Copy(_attributes, 0, n, 0, _attrCount); 4174Array.Copy(_data, _tokDataPos, data, 0, _tokLen); 4354Array.Copy(_data, _tokDataPos, data, 0, _tokLen);

FrameworkFork\Microsoft.Xml\Xml\BinHexDecoder.cs (1)

172Array.Copy(bytes, 0, tmp, 0, bytesDecoded);

FrameworkFork\Microsoft.Xml\Xml\BufferBuilder.cs (1)

487Array.Copy(_buffers, 0, newBuffers, 0, _buffers.Length);

FrameworkFork\Microsoft.Xml\Xml\Core\XmlEventCache.cs (1)

578Array.Copy(buffer, index, bufferNew, 0, count);

FrameworkFork\Microsoft.Xml\Xml\Core\XmlSubtreeReader.cs (1)

1302Array.Copy(_nsAttributes, 0, newNsAttrs, 0, index);

FrameworkFork\Microsoft.Xml\Xml\Core\XmlTextReaderImpl.cs (4)

4594Array.Copy(_nodes, _index + 1, nameSortedAttributes, 0, _attrCount); 5135Array.Copy(_nodes, _index + 1, _attrDuplSortingArray, 0, _attrCount); 7789Array.Copy(_nodes, 0, newNodes, 0, _nodes.Length); 8248Array.Copy(_parsingStatesStack, 0, newParsingStateStack, 0, _parsingStatesStack.Length);

FrameworkFork\Microsoft.Xml\Xml\Core\XsdCachingReader.cs (2)

674Array.Copy(_attributeEvents, 0, newAttributeEvents, 0, _attributeEvents.Length); 699Array.Copy(_contentEvents, 0, newContentEvents, 0, _contentEvents.Length);

FrameworkFork\Microsoft.Xml\Xml\Core\XsdValidatingReader.cs (1)

2196Array.Copy(_attributePSVINodes, 0, newPSVINodes, 0, _attributePSVINodes.Length);

FrameworkFork\Microsoft.Xml\Xml\Dom\DocumentSchemaValidator.cs (1)

572Array.Copy(_nodeSequenceToValidate, 0, newNodeSequence, 0, _nodeSequenceToValidate.Length);

FrameworkFork\Microsoft.Xml\Xml\HWStack.cs (1)

44System.Array.Copy(_stack, 0, newstack, 0, _used);

FrameworkFork\Microsoft.Xml\Xml\schema\ContentValidator.cs (2)

2105Array.Copy(rposInfo.rangeCounters, 0, newRPosInfo.rangeCounters, 0, rposInfo.rangeCounters.Length); 2132Array.Copy(rposInfo.rangeCounters, 0, newRPosInfo.rangeCounters, 0, rposInfo.rangeCounters.Length);

FrameworkFork\Microsoft.Xml\Xml\schema\DtdParser.cs (1)

1458Array.Copy(_condSectionEntityIds, 0, tmp, 0, _condSectionEntityIds.Length);

FrameworkFork\Microsoft.Xml\Xml\Serialization\Mappings.cs (2)

395Array.Copy(_elements, 0, _sortedElements, 0, _elements.Length); 792Array.Copy(_elements, 0, _sortedElements, 0, _elements.Length);

FrameworkFork\Microsoft.Xml\Xml\XmlNamespaceManager.cs (1)

172Array.Copy(_nsdecls, 0, newNsdecls, 0, _nsdecls.Length);

FrameworkFork\Microsoft.Xml\Xml\XPath\Internal\XPathMultyIterator.cs (1)

54Array.Copy(arr, firstNotEmpty, arr, firstNotEmpty + 1, pos - firstNotEmpty);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\ClassDataContract.cs (4)

507Array.Copy(baseChildElementNamespaces, 0, childElementNamespaces, 0, baseChildElementNamespaces.Length); 835Array.Copy(BaseContract.MemberNames, 0, MemberNames, 0, baseMemberCount); 837Array.Copy(BaseContract.MemberNamespaces, 0, MemberNamespaces, 0, baseMemberCount); 840Array.Copy(BaseContract.ContractNamespaces, 0, ContractNamespaces, 0, baseContractCount);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\ExceptionDataContract.cs (1)

185Array.Copy(BaseContract._contractNamespaces, 0, _contractNamespaces, 0, baseContractCount);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\ExtensionDataReader.cs (2)

501Array.Copy(_elements, 0, newElements, 0, _elements.Length); 586Array.Copy(attributes, 0, newAttributes, 0, attributes.Length);

FrameworkFork\System.Runtime.Serialization\System\Runtime\Serialization\XmlObjectSerializerReadContext.cs (2)

479Array.Copy(array, 0, newArray, 0, array.Length); 494Array.Copy(array, 0, newArray, 0, size);

FrameworkFork\System.Runtime.Serialization\System\Xml\ArrayHelper.cs (2)

53Array.Copy(arrays[i], 0, newArray, offset, arrays[i].Length); 56Array.Copy(array, 0, newArray, offset, totalRead - offset);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBaseReader.cs (10)

300Array.Copy(_elementNodes, 0, newElementNodes, 0, _depth); 334Array.Copy(_attributeNodes, 0, newAttributeNodes, 0, attributeIndex); 1373Array.Copy(_trailBytes, 0, buffer, offset, actual); 1375Array.Copy(_trailBytes, actual, _trailBytes, 0, _trailByteCount); 1399Array.Copy(_trailChars, 0, chars, charCount, _trailCharCount); 1432Array.Copy(chars, charCount, _trailChars, 0, _trailCharCount); 1443Array.Copy(_trailBytes, 0, buffer, offset, actual); 1445Array.Copy(_trailBytes, actual, _trailBytes, 0, _trailByteCount); 2697Array.Copy(_attributes, 0, newAttributes, 0, _attributeCount); 2735Array.Copy(_namespaces, 0, newNamespaces, 0, _nsCount);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBaseWriter.cs (3)

619Array.Copy(_elements, 0, newElementNodes, 0, _depth); 1856Array.Copy(_attributes, 0, newAttributes, 0, _attributeCount); 1950Array.Copy(_namespaces, 0, newNamespaces, 0, _nsCount);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBinaryReaderSession.cs (1)

52Array.Copy(_strings, 0, newStrings, 0, _strings.Length);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlBinaryWriterSession.cs (1)

253Array.Copy(_array, 0, newArray, 0, _array.Length);

FrameworkFork\System.Runtime.Serialization\System\Xml\XmlStreamNodeWriter.cs (1)

472Array.Copy(newBytes, 0, buffer, (int)(bytes - _bytes) + offset, toCopy);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\BufferedWriteStream.cs (3)

86Array.Copy(_buffer, 0, shadowBuffer, 0, _writePos); 244Array.Copy(array, offset, _buffer, _writePos, bytesToWrite); 380Array.Copy(array, offset, _buffer, _writePos, count);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\Message.cs (1)

2071Array.Copy(_entries, 1, _entries, 0, _entries.Length - 1);

FrameworkFork\System.ServiceModel\System\ServiceModel\Channels\MessageHeaders.cs (2)

1265Array.Copy(_headers, headerIndex, _headers, headerIndex + 1, _headerCount - headerIndex); 1421Array.Copy(_headers, headerIndex + 1, _headers, headerIndex, _headerCount - headerIndex - 1);

FrameworkFork\System.ServiceModel\System\ServiceModel\Description\ClientClassGenerator.cs (1)

141Array.Copy(arr, 0, newArr, 1, arr.Length);

CustomTextMessageEncoder.cs (2)

63Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length); 95Array.Copy(messageBuffer.Array, 0, totalBytes, messageOffset, messageLength);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

SegmentedArrayBenchmarks_Indexer.cs (2)

46Array.Copy(_values, 1, _values, 0, _values.Length - 1); 64Array.Copy(_valuesObject, 1, _valuesObject, 0, _valuesObject.Length - 1);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Components\Shared\src\ArrayBuilder.cs (1)

153Array.Copy(_items, index, _items, index + 1, _itemsInUse - index);

src\Http\Http.Abstractions\src\Routing\RouteValueDictionary.cs (5)

460Array.Copy(storage, 0, array, arrayIndex, _count); 497Array.Copy(array, index + 1, array, index, _count - index); 528Array.Copy(array, index + 1, array, index, _count - index); 568Array.Copy(array, index + 1, array, index, _count - index); 698Array.Copy(_arrayStorage, 0, array, 0, _count);

Circuits\CircuitIdFactory.cs (2)

38Array.Copy( 70Array.Copy(

src\Components\Shared\src\ArrayBuilder.cs (1)

153Array.Copy(_items, index, _items, index + 1, _itemsInUse - index);

src\Components\Shared\src\ArrayBuilder.cs (1)

153Array.Copy(_items, index, _items, index + 1, _itemsInUse - index);

KeyManagement\KeyRingBasedDataProtector.cs (1)

54Array.Copy(originalPurposes, 0, newPurposes, 0, originalPurposes.Length);

src\Shared\Dictionary\AdaptiveCapacityDictionary.cs (5)

310Array.Copy(storage, 0, array, arrayIndex, _count); 359Array.Copy(array, index + 1, array, index, _count - index); 391Array.Copy(array, index + 1, array, index, _count - index); 432Array.Copy(array, index + 1, array, index, _count - index); 534Array.Copy(_arrayStorage, 0, array, 0, _count);

Extensions\UseMiddlewareExtensions.cs (1)

130Array.Copy(_args, 0, ctorArgs, 1, _args.Length);

Routing\RouteValueDictionary.cs (6)

240Array.Copy(other, 0, storage, 0, count); 460Array.Copy(storage, 0, array, arrayIndex, _count); 497Array.Copy(array, index + 1, array, index, _count - index); 528Array.Copy(array, index + 1, array, index, _count - index); 568Array.Copy(array, index + 1, array, index, _count - index); 698Array.Copy(_arrayStorage, 0, array, 0, _count);

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (3)

37Array.Copy(data, 0, startSegment, 10, data.Length); 52Array.Copy(data, 0, startSegment, 10, data.Length); 67Array.Copy(data, 0, startSegment, 10, data.Length);

src\Shared\PropertyAsParameterInfo.cs (2)

153Array.Copy(propertyAttributes, 0, mergedAttributes, constructorAttributes.Length, propertyAttributes.Length); 173Array.Copy(propertyAttributes, 0, mergedAttributes, constructorAttributes.Length, propertyAttributes.Length);

src\Shared\PropertyAsParameterInfo.cs (2)

153Array.Copy(propertyAttributes, 0, mergedAttributes, constructorAttributes.Length, propertyAttributes.Length); 173Array.Copy(propertyAttributes, 0, mergedAttributes, constructorAttributes.Length, propertyAttributes.Length);

Buffers\PagedCharBuffer.cs (1)

84Array.Copy(

Buffers\ViewBuffer.cs (1)

345Array.Copy(

src\Shared\PropertyAsParameterInfo.cs (2)

153Array.Copy(propertyAttributes, 0, mergedAttributes, constructorAttributes.Length, propertyAttributes.Length); 173Array.Copy(propertyAttributes, 0, mergedAttributes, constructorAttributes.Length, propertyAttributes.Length);

ArrayBuilder.cs (2)

119Array.Copy(_array, 0, result, 0, _count); 163Array.Copy(_array, 0, next, 0, _count);

Matching\DfaMatcher.cs (1)

138Array.Copy(prototype, 0, slots, 0, prototype.Length);

Template\TemplateBinder.cs (1)

165Array.Copy(_slots, 0, slots, 0, slots.Length);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (3)

37Array.Copy(data, 0, startSegment, 10, data.Length); 52Array.Copy(data, 0, startSegment, 10, data.Length); 67Array.Copy(data, 0, startSegment, 10, data.Length);

UTF8Decoding.cs (1)

37Array.Copy(bytes, 0, byteRange, position, bytes.Length);

src\Shared\Dictionary\AdaptiveCapacityDictionary.cs (5)

310Array.Copy(storage, 0, array, arrayIndex, _count); 359Array.Copy(array, index + 1, array, index, _count - index); 391Array.Copy(array, index + 1, array, index, _count - index); 432Array.Copy(array, index + 1, array, index, _count - index); 534Array.Copy(_arrayStorage, 0, array, 0, _count);

src\Shared\runtime\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (3)

37Array.Copy(data, 0, startSegment, 10, data.Length); 52Array.Copy(data, 0, startSegment, 10, data.Length); 67Array.Copy(data, 0, startSegment, 10, data.Length);

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (3)

37Array.Copy(data, 0, startSegment, 10, data.Length); 52Array.Copy(data, 0, startSegment, 10, data.Length); 67Array.Copy(data, 0, startSegment, 10, data.Length);

TestWebSocket.cs (2)

143Array.Copy(receiveMessage.Buffer.Array!, receiveMessage.Buffer.Offset, buffer.Array!, buffer.Offset, count); 291Array.Copy(message.Buffer.Array!, message.Buffer.Offset, array, 0, message.Buffer.Count);

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (3)

37Array.Copy(data, 0, startSegment, 10, data.Length); 52Array.Copy(data, 0, startSegment, 10, data.Length); 67Array.Copy(data, 0, startSegment, 10, data.Length);

src\Shared\Buffers.Testing\ReadOnlySequenceFactory.cs (3)

37Array.Copy(data, 0, startSegment, 10, data.Length); 52Array.Copy(data, 0, startSegment, 10, data.Length); 67Array.Copy(data, 0, startSegment, 10, data.Length);

BackEnd\Components\RequestBuilder\RequestBuilder.cs (1)

585Array.Copy(handles, 0, allHandles, 1, handles.Length);

BufferedReadStream.cs (7)

78Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount); 89Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, count); 100Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount); 121Array.Copy(_buffer, 0, buffer, offset + alreadyCopied, remainingCopyCount); 145Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, count); 162Array.Copy(_buffer, 0, buffer, offset + alreadyCopied, remainingCopyCount); 174Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount);

Collections\RetrievableEntryHashSet\RetrievableEntryHashSet.cs (1)

791Array.Copy(_slots, 0, newSlots, 0, _lastIndex);

SegmentedArray.cs (2)

66Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 161Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

Hash.cs (2)

156Array.Copy(byteBuffer, bytesProcessed, shaBuffer, shaBufferPosition, shaBufferFreeSpace); 165Array.Copy(byteBuffer, bytesProcessed, shaBuffer, shaBufferPosition, byteCount);

StreamMappedString.cs (1)

275Array.Copy(_priorPage, i + 1, _priorPage, i, _charactersRead - i - 1);

InternalUtilities\ArrayExtensions.cs (4)

25Array.Copy(array, start, newArray, 0, length); 39Array.Copy(array, position, newArray, position + 1, array.Length - position); 61Array.Copy(array, position, newArray, position + items.Length, array.Length - position); 93Array.Copy(array, position + length, newArray, position, newArray.Length - position);

InternalUtilities\WeakList.cs (2)

63Array.Copy(_items, 0, newItems, 0, _items.Length); 104Array.Copy(_items, 0, result, 0, firstDead);

src\Dependencies\Collections\Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

Syntax\InternalSyntax\SyntaxList.WithManyChildren.cs (1)

58Array.Copy(this.children, 0, array, offset, this.children.Length);

Text\LargeText.cs (1)

169Array.Copy(chunk, chunkStartOffset, destination, destinationIndex, charsToCopy);

Text\LargeTextWriter.cs (1)

107Array.Copy(chars, index, _buffer, _currentUsed, copy);

Text\SourceTextStream.cs (1)

128Array.Copy(preambleBytes, 0, buffer, offset, length);

src\Compilers\Core\Portable\InternalUtilities\ArrayExtensions.cs (4)

25Array.Copy(array, start, newArray, 0, length); 39Array.Copy(array, position, newArray, position + 1, array.Length - position); 61Array.Copy(array, position, newArray, position + items.Length, array.Length - position); 93Array.Copy(array, position + length, newArray, position, newArray.Length - position);

src\Dependencies\Collections\Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SerializableBytes.cs (2)

197Array.Copy(chunk, currentOffset, buffer, index, copyCount); 384Array.Copy(buffer, currentIndex, chunk, currentOffset, writeCount);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\SyntaxAnnotationExtensions.cs (1)

32Array.Copy(originalAnnotations, 0, finalAnnotations, newAnnotations.Length, originalAnnotations.Length);

Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

Parser\SlidingTextWindow.cs (2)

210Array.Copy(_characterWindow, 226Array.Copy(oldWindow, 0, newWindow, 0, _characterWindowCount);

Parser\SyntaxParser.cs (2)

410Array.Copy(_blendedTokens, shiftOffset, _blendedTokens, 0, shiftCount); 437Array.Copy(_lexedTokens, shiftOffset, _lexedTokens, 0, shiftCount);

src\Dependencies\Collections\Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

src\Dependencies\Collections\Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

CryptoBlobParserTests.cs (1)

151Array.Copy(snBlob, CryptoBlobParser.s_publicKeyHeaderSize, buf, 0, buf.Length);

Emit\CustomDebugInfoTests.cs (1)

569Array.Copy(array, 0, result, 0, array.Length);

InternalUtilities\StreamExtensionsTests.cs (2)

31Array.Copy(sourceArray, sourceOffset, buf, offset, count); 74Array.Copy(sourceArray, 0, buf, offset, count);

Shared\Extensions\SourceTextExtensions.cs (1)

354Array.Copy(chunk, chunkStartOffset, buffer, index, charsToCopy);

src\Compilers\Core\Portable\InternalUtilities\ArrayExtensions.cs (4)

25Array.Copy(array, start, newArray, 0, length); 39Array.Copy(array, position, newArray, position + 1, array.Length - position); 61Array.Copy(array, position, newArray, position + items.Length, array.Length - position); 93Array.Copy(array, position + length, newArray, position, newArray.Length - position);

src\Dependencies\Collections\Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SerializableBytes.cs (2)

197Array.Copy(chunk, currentOffset, buffer, index, copyCount); 384Array.Copy(buffer, currentIndex, chunk, currentOffset, writeCount);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\SyntaxAnnotationExtensions.cs (1)

32Array.Copy(originalAnnotations, 0, finalAnnotations, newAnnotations.Length, originalAnnotations.Length);

src\Compilers\Core\Portable\InternalUtilities\ArrayExtensions.cs (4)

25Array.Copy(array, start, newArray, 0, length); 39Array.Copy(array, position, newArray, position + 1, array.Length - position); 61Array.Copy(array, position, newArray, position + items.Length, array.Length - position); 93Array.Copy(array, position + length, newArray, position, newArray.Length - position);

src\Compilers\Core\Portable\InternalUtilities\WeakList.cs (2)

63Array.Copy(_items, 0, newItems, 0, _items.Length); 104Array.Copy(_items, 0, result, 0, firstDead);

src\Dependencies\Collections\Segmented\SegmentedArray.cs (2)

72Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: copied, length: segment.Count); 167Array.Copy(segment.Array!, sourceIndex: segment.Offset, destinationArray: destinationArray, destinationIndex: destinationIndex + copied, length: segment.Count);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SerializableBytes.cs (2)

197Array.Copy(chunk, currentOffset, buffer, index, copyCount); 384Array.Copy(buffer, currentIndex, chunk, currentOffset, writeCount);

Microsoft\CSharp\RuntimeBinder\RuntimeBinder.cs (1)

182Array.Copy(args, 1, newArgs, 0, args.Length - 1);

Microsoft\CSharp\RuntimeBinder\Semantics\Types\TypeArray.cs (2)

105public void CopyItems(int i, int c, CType[] dest) => Array.Copy(Items, i, dest, 0, c); 159Array.Copy(prgtype2, 0, combined, prgtype1.Length, prgtype2.Length);

TextFieldParser.cs (1)

650Array.Copy(_buffer, _position, tempArray, 0, bufferLength - _position);

src\Microsoft.Data.Analysis\TextFieldParser.cs (1)

650Array.Copy(_buffer, _position, tempArray, 0, bufferLength - _position);

src\GenerateGuidFromName.cs (1)

34Array.Copy(nameBytes, 0, streamToHash, namespaceBytes.Length, nameBytes.Length);

Program.cs (1)

125Array.Copy(arr, offset, newArr, 0, count);

Signing.cs (1)

366Array.Copy(hash, hash.Length - 8, token, 0, 8);

StringValues.cs (1)

363Array.Copy(values, 0, array, arrayIndex, values.Length);

src\Components\Shared\src\ArrayBuilder.cs (1)

153Array.Copy(_items, index, _items, index + 1, _itemsInUse - index);

Extensions\ArrayExtensions.cs (2)

24 Array.Copy(self, index, result, index + 1, result.Length - index - 1); 55 Array.Copy(self, index + 1, result, index, self.Length - index - 1);

SetterSpecificityList.cs (4)

143 Array.Copy(_keys, lo, _keys, lo + 1, count - lo); 144 Array.Copy(_values, lo, _values, lo + 1, count - lo); 197 Array.Copy(_keys, nextIndex, _keys, index, count - nextIndex); 198 Array.Copy(_values, nextIndex, _values, index, count - nextIndex);

Sweepers\SmacSweeper.cs (2)

165Array.Copy(eiChallengers, 0, configs, 0, eiChallengers.Length); 166Array.Copy(randomChallengers, 0, configs, eiChallengers.Length, randomChallengers.Length);

Utils\ArrayMath.cs (2)

61Array.Copy(array, 0, ret, 0, index); 63Array.Copy(array, index, ret, index + 1, array.Length - index);

Utilities\Utils.cs (2)

868Array.Copy(b, 0, res, a.Length, b.Length); 907Array.Copy(a, 0, res, ivDst, cv);

AlignedArray.cs (2)

87Array.Copy(Items, _base, Items, newBase, _size); 166Array.Copy(src.Items, src._base, Items, _base, _size);

Dataset\Dataset.cs (6)

394Array.Copy(activeFeatures, 0, truncatedActiveFeatures, 0, NumFeatures); 601Array.Copy(perm, posInPerm, queries[p], 0, numQueries[p]); 716Array.Copy(parts[p].Ratings, 0, concatRatings, docBegin, numDocs); 717Array.Copy(parts[p].DocIds, 0, concatDocIds, docBegin, numDocs); 718Array.Copy(parts[p].QueryIds, 0, concatQueryIds, queryBegin, numQueries); 854Array.Copy(arrays[i], 0, a, start, lengths[i]);

Dataset\FeatureFlock.cs (1)

121Array.Copy(active, featureOffset, _active, 0, _active.Length);

FastTreeRanking.cs (2)

763Array.Copy(_labels, begin, _labelsCopy, begin, numDocuments); 770Array.Copy(Scores, begin, _scoresCopy, begin, numDocuments);

Training\DcgCalculator.cs (1)

547Array.Copy(permutation, 0, result, begin, count);

Training\DocumentPartitioning.cs (3)

229Array.Copy(_tempDocuments, begin, _documents, newEnd, gtCount); 277Array.Copy(_tempDocuments, begin, _documents, newEnd, gtCount); 353Array.Copy(_documents, _leafBegin[leaf], documents, 0, _leafCount[leaf]);

Utils\Algorithms.cs (3)

158Array.Copy(arrays[i], 0, working, begin, arrays[i].Length); 179Array.Copy(tmp, begins[fromArray], working, begins[fromArray], length); 188Array.Copy(tmp, begins[fromArray], working, begins[fromArray], length);

Utils\CompressUtils.cs (1)

49Array.Copy(block.Buffer, block.Offset, block.Buffer, 0, block.Length);

Utils\ToByteArrayExtensions.cs (4)

231Array.Copy(bytes, 0, buffer, position, bytes.Length); 241Array.Copy(bytes, 0, allBytes, position, bytes.Length); 263Array.Copy(a, 0, buffer, position, a.Length); 272Array.Copy(buffer, position, a, 0, length);

NameAnalyzer.cs (1)

40Array.Copy(args, 0, newArgs, 1, args.Length);

PcaTransformer.cs (1)

643Array.Copy(transformInfo.Eigenvectors[i], 0, principalComponents, i * transformInfo.Dimension, transformInfo.Dimension);

Optimizer\Optimizer.cs (2)

346Array.Copy(_sList, 1, _sList, 0, _m - 1); 348Array.Copy(_yList, 1, _yList, 0, _m - 1);

Standard\MulticlassClassification\MulticlassNaiveBayesTrainer.cs (2)

432Array.Copy(_featureHistogram[i], 0, featureHistogram, i * _featureHistogram[i].Length, _featureHistogram[i].Length); 436Array.Copy(_labelHistogram, 0, labelHistogramExpanded, i * _featureHistogram.Length, _featureHistogram.Length);

Algorithms\SmacSweeper.cs (2)

176Array.Copy(eiChallengers, 0, configs, 0, eiChallengers.Length); 177Array.Copy(randomChallengers, 0, configs, eiChallengers.Length, randomChallengers.Length);

DataPipe\TestDataPipeBase.cs (1)

454Array.Copy(args2, 0, res, args1.Length, args2.Length);

EigenUtils.cs (1)

527Array.Copy(input, 0, a, 0, n2);

PolynomialUtils.cs (1)

106Array.Copy(coefficients, i, coeff, 0, n - i);

TrajectoryMatrix.cs (1)

248Array.Copy(sVec, _windowSize * ind[i], leftSingularvectors, _windowSize * i, _windowSize);

UnigramTests.cs (6)

359Array.Copy(ids, 0, expectedIds, 1, ids.Length); 361Array.Copy(ids, 0, expectedIds, ids.Length + 2, ids.Length); 367Array.Copy(tokens, 0, expectedTokens, 1, tokens.Length); 369Array.Copy(tokens, 0, expectedTokens, tokens.Length + 2, tokens.Length); 467Array.Copy(ids, 0, expectedIds, 1, ids.Length); 469Array.Copy(ids, 0, expectedIds, ids.Length + 2, ids.Length);

Expression\CodeGen.cs (1)

73Array.Copy(types, 0, types, 1, types.Length - 1);

Microsoft\VisualBasic\CompilerServices\Utils.vb (1)

111Global.System.Array.Copy(arySrc, i * lenSrcLastRank, aryDest, i * lenDestLastRank, lenCopy)

Microsoft\VisualBasic\FileIO\FileSystem.vb (2)

2205Array.Copy(sourceArray:=m_PreviousCharBuffer, sourceIndex:=0, 2218Array.Copy(sourceArray:=CharBuffer, sourceIndex:=(CharBuffer.Length - m_SearchText.Length),

Microsoft\VisualBasic\FileIO\TextFieldParser.vb (1)

696Array.Copy(m_Buffer, m_Position, m_Buffer, 0, ContentLength)

BufferedReadStream.cs (7)

78Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount); 89Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, count); 100Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount); 121Array.Copy(_buffer, 0, buffer, offset + alreadyCopied, remainingCopyCount); 145Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, count); 162Array.Copy(_buffer, 0, buffer, offset + alreadyCopied, remainingCopyCount); 174Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount);

XMake.cs (1)

397Array.Copy(args, 0, newArgArray, 1, args.Length);

BufferedReadStream.cs (4)

78Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount); 89Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, count); 100Array.Copy(_buffer, _currentIndexInBuffer, buffer, offset, _currentlyBufferedByteCount); 121Array.Copy(_buffer, 0, buffer, offset + alreadyCopied, remainingCopyCount);

Concurrent\ConcurrentDictionary.cs (1)

408Array.Copy(tables._locks, 0, newLocks, 0, tables._locks.Length);

src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XmlnsDictionary.cs (1)

636Array.Copy(_nsDeclarations, 0, new_nsDeclarations, 0, _nsDeclarations.Length);

MS\Internal\Shaping\OpenTypeLayout.cs (2)

1318Array.Copy(_cachePointers, oldAfterLastGlyphChanged, tmp, afterLastGlyphChanged, oldLength - oldAfterLastGlyphChanged); 1324Array.Copy(_cachePointers, oldAfterLastGlyphChanged, _cachePointers, afterLastGlyphChanged, oldLength - oldAfterLastGlyphChanged);

System\Windows\ClassHandlersStore.cs (1)

62Array.Copy(handlers.Handlers, 0, mergedHandlers, 0, length);

System\Windows\Input\Stylus\Common\TabletDeviceCollection.cs (1)

50Array.Copy(TabletDevices.ToArray(), 0, array, index, Count);

System\Windows\InterOp\HwndPointerInputProvider.cs (1)

168Array.Copy(rawPointerData, j, data, i, rawDataPointSize);

System\Windows\Media\FamilyMapCollection.cs (2)

83Array.Copy(_items, 0, array, index, _count); 104Array.Copy(_items, 0, array, index, _count);

System\Windows\Media\FamilyTypefaceCollection.cs (1)

384Array.Copy(_items, 0, array, index, _count);

System\Windows\Media\VisualCollection.cs (1)

254Array.Copy(_items, 0, newItems, 0, _size);

MS\Internal\Data\RBNode.cs (1)

303Array.Copy(sourceNode._data, sourceOffset, destNode._data, destOffset, count);

MS\Internal\Documents\ContentElementCollection.cs (3)

80Array.Copy(Items, 0, array, index, Size); 112Array.Copy(Items, 0, array, index, Size); 765Array.Copy(Items, 0, newItems, 0, Size);

MS\Internal\IO\Packaging\ByteStream.cs (1)

298Array.Copy(localBuffer, 0, buffer, offset, read);

MS\Internal\PtsHost\DtrList.cs (1)

126Array.Copy(_dtrs, i, _dtrs, i+1, _count-i);

MS\Internal\UncommonValueTable.cs (4)

50Array.Copy(_table, 0, newTable, 0, index); 51Array.Copy(_table, index, newTable, index+1, n-index); 77Array.Copy(_table, 0, newTable, 0, index); 78Array.Copy(_table, index+1, newTable, index, n-index);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Utility\ItemMap.cs (2)

42Array.Copy(Entries, 0, destEntries, 0, index); 46Array.Copy(Entries, index, destEntries, index + 1, Count - index);

System\Windows\Controls\ColumnDefinition.cs (3)

92Array.Copy(_items, 0, array, index, _size); 114Array.Copy(_items, 0, array, index, _size); 706Array.Copy(_items, 0, newItems, 0, _size);

System\Windows\Controls\Primitives\Track.cs (1)

136Array.Copy(_visualChildren, itemIndex + 1, _visualChildren, itemIndex, nullIndex - itemIndex);

System\Windows\Controls\RowDefinition.cs (3)

87Array.Copy(_items, 0, array, index, _size); 109Array.Copy(_items, 0, array, index, _size); 701Array.Copy(_items, 0, newItems, 0, _size);

System\Windows\Data\BindingExpression.cs (1)

1232Array.Copy(newWorkerSources, 0, newSources, offset, n);

System\Windows\Data\BindingExpressionBase.cs (2)

472Array.Copy(temp, 0, result, 0, j); 2884Array.Copy(sources, 0, temp, 0, n);

System\Windows\Documents\FlowPosition.cs (2)

224Array.Copy(text.ToCharArray(flow._offset, maxLength), 0, chars, startIndex, maxLength); 228Array.Copy(text.ToCharArray(flow._offset - maxLength, maxLength), 0, chars, startIndex, maxLength);

System\Windows\Documents\ImmComposition.cs (2)

928Array.Copy(resultChars, 0, compositionText, 0, resultLength); 929Array.Copy(compositionChars, 0, compositionText, resultLength, compositionLength);

System\Windows\Documents\TextElementCollectionHelper.cs (1)

116Array.Copy(_cleanParentList, 0, _cleanParentList, 1, index);

System\Windows\Documents\TextPointerBase.cs (2)

1459Array.Copy(preceedingText, SelectionWordBreaker.MinContextLength - preceedingCount, text, 0, preceedingCount); 1460Array.Copy(followingText, 0, text, preceedingCount, followingCount);

System\Windows\Documents\TextSchema.cs (5)

55Array.Copy(textElementPropertyList, 0, _inheritableTextElementProperties, 0, textElementPropertyList.Length); 56Array.Copy(Typography.TypographyPropertiesList, 0, _inheritableTextElementProperties, textElementPropertyList.Length, Typography.TypographyPropertiesList.Length); 67Array.Copy(blockPropertyList, 0, _inheritableBlockProperties, 0, blockPropertyList.Length); 68Array.Copy(_inheritableTextElementProperties, 0, _inheritableBlockProperties, blockPropertyList.Length, _inheritableTextElementProperties.Length); 79Array.Copy(_inheritableTextElementProperties, 0, _inheritableTableCellProperties, tableCellPropertyList.Length, _inheritableTextElementProperties.Length);

System\Windows\Documents\TextTreeTextBlock.cs (8)

94Array.Copy(_text, 0, newText, 0, _gapOffset); 96Array.Copy(_text, _gapOffset + _gapSize, newText, newText.Length - rightOfGapLength, rightOfGapLength); 121Array.Copy(textChars, textStartIndex, _text, logicalOffset, count); 149Array.Copy(_text, 0, newBlock._text, 0, _gapOffset); 163Array.Copy(_text, _gapOffset, newBlock._text, _gapOffset, MaxBlockSize - _gapOffset); 248Array.Copy(_text, logicalOffset, chars, charsStartIndex, copyCount); 263Array.Copy(_text, logicalOffset, chars, charsStartIndex, copyCount); 481Array.Copy(_text, sourceOffset, _text, destinationOffset, count);

System\Windows\Markup\XmlnsDictionary.cs (1)

636Array.Copy(_nsDeclarations, 0, new_nsDeclarations, 0, _nsDeclarations.Length);

DynamicAccessorImpl.cs (3)

113Array.Copy(args, 0, delegateArgs, 2, rank); 124Array.Copy(args, 0, delegateArgs, 2, rank); 140Array.Copy(_accessors, 0, newAccessors, 0, _accessors.Length);

AlphaFlattener\Utility.cs (1)

1404Array.Copy(

MS\Internal\Printing\Configuration\DevMode.cs (1)

473Array.Copy(ticketDevMode.ByteData, this.dmFieldsByteOffset, this.ByteData, this.dmFieldsByteOffset, this.ByteData.Length - this.dmFieldsByteOffset);

PrintConfig\PTProvider.cs (1)

676Array.Copy(src, (int)totalBytesWritten, data, 0, bytesToWrite);

Serialization\Manager\ReachSerializationUtils.cs (2)

222Array.Copy(List, 0, array, 0, Count); 258Array.Copy(List, index + 1, List, index, (Count - index - 1));

System\Collections\BitArray.cs (3)

632Array.Copy(m_array, fromIndex, m_array, 0, ints - fromIndex); 684Array.Copy(m_array, 0, m_array, lengthToClear, lastIndex + 1 - lengthToClear); 766Array.Copy(m_array, 0, intArray, index, quotient);

System\Collections\Generic\PriorityQueue.cs (1)

980Array.Copy(_queue._nodes, 0, array, index, _queue._size);

System\Collections\Generic\SortedList.cs (8)

662Array.Copy(keys, index, keys, index + 1, _size - index); 663Array.Copy(values, index, values, index + 1, _size - index); 693Array.Copy(keys, index + 1, keys, index, _size - index); 694Array.Copy(values, index + 1, values, index, _size - index); 1049Array.Copy(_dict.keys, 0, array, arrayIndex, _dict.Count); 1060Array.Copy(_dict.keys, 0, array!, arrayIndex, _dict.Count); 1163Array.Copy(_dict.values, 0, array, arrayIndex, _dict.Count); 1174Array.Copy(_dict.values, 0, array!, index, _dict.Count);

System\Collections\Generic\Stack.cs (1)

146Array.Copy(_array, 0, array, arrayIndex, _size);

System\Collections\Concurrent\BlockingCollection.cs (1)

1566Array.Copy(collectionSnapShot, 0, array, index, collectionSnapShot.Length);

System\Collections\Concurrent\ConcurrentBag.cs (2)

799Array.Copy(_array, headIdx, newArray, 0, _array.Length - headIdx); 800Array.Copy(_array, 0, newArray, _array.Length - headIdx, headIdx);

System\Collections\Concurrent\PartitionerStatic.cs (1)

652Array.Copy(fillBufferLocalRef, beginPos, destArray, 0, actualNumElementsGrabbed);

System\Collections\Frozen\FrozenSet.cs (1)

292Array.Copy(items, 0, array!, index, items.Length);

System\Collections\Immutable\ImmutableArray.cs (1)

263Array.Copy(items.array!, start, array, 0, length);

System\Collections\Immutable\ImmutableArray_1.Builder.cs (14)

System\Collections\Immutable\ImmutableArray_1.cs (9)

333Array.Copy(self.array!, index, tmp, index + 1, self.Length - index); 371Array.Copy(self.array!, index, tmp, index + count, self.Length - index); 468Array.Copy(items, 0, tmp, self.Length, length); 492Array.Copy(items, 0, tmp, self.Length, items.Length); 662Array.Copy(self.array!, index + length, tmp, index, self.Length - index - length); 1375Array.Copy(self.array!, 0, array, index, self.Length); 1497Array.Copy(self.array!, copied + removed, newArray, copied, copyLength); 1503Array.Copy(self.array!, copied + removed, newArray, copied, self.Length - (copied + removed)); 1522Array.Copy(array!, index, tmp, index + items.Length, Length - index);

System\Collections\Immutable\ImmutableArray_1.Minimal.cs (2)

242Array.Copy(self.array!, 0, destination, destinationIndex, self.Length); 256Array.Copy(self.array!, sourceIndex, destination, destinationIndex, length);

System\Collections\Immutable\ImmutableExtensions.Minimal.cs (2)

120Array.Copy(sourceArray, 0, array, arrayIndex, sourceArray.Length); 126Array.Copy(immutable.array!, 0, array, arrayIndex, immutable.Length);

System\Collections\Queue.cs (10)

System\Collections\SortedList.cs (6)

500Array.Copy(keys, index, keys, index + 1, _size - index); 501Array.Copy(values, index, values, index + 1, _size - index); 518Array.Copy(keys, index + 1, keys, index, _size - index); 519Array.Copy(values, index + 1, values, index, _size - index); 944Array.Copy(sortedList.keys, 0, array!, arrayIndex, sortedList.Count); 1047Array.Copy(sortedList.values, 0, array!, arrayIndex, sortedList.Count);

System\ComponentModel\AttributeCollection.cs (1)

342public void CopyTo(Array array, int index) => Array.Copy(Attributes, 0, array, index, Attributes.Length);

System\ComponentModel\Container.cs (1)

203Array.Copy(_sites, i + 1, _sites, i, _siteCount - i);

System\ComponentModel\EventDescriptorCollection.cs (3)

120Array.Copy(_events, 0, array, index, Count); 211Array.Copy(_events, index, _events, index + 1, Count - index); 241Array.Copy(_events, index + 1, _events, index, Count - index - 1);

System\ComponentModel\PropertyDescriptorCollection.cs (3)

127Array.Copy(_properties, 0, array, index, Count); 244Array.Copy(_properties, index, _properties, index + 1, Count - index); 274Array.Copy(_properties, index + 1, _properties, index, Count - index - 1);

System\Data\Common\DataRecordInternal.cs (2)

140Array.Copy(data, ndataIndex, buffer, bufferIndex, cbytes); 216Array.Copy(data, ndataIndex, buffer, bufferIndex, cchars);

System\Data\DataError.cs (1)

85Array.Copy(_errorList, i + 1, _errorList, i, _count - i - 1);

System\Data\Odbc\OdbcDataReader.cs (1)

1194Array.Copy((byte[])cachedObj, (int)dataIndex, (byte[])buffer, bufferIndex, lengthOfCopy);

System\Diagnostics\ActivitySource.cs (1)

482Array.Copy(

System\IO\Compression\DeflateManaged\InflaterManaged.cs (1)

679Array.Copy(_codeList, _literalLengthCodeCount, distanceTreeCodeLength, 0, _distanceCodeCount);

System\IO\Compression\DeflateManaged\OutputWindow.cs (1)

55Array.Copy(_window, copyStart, _window, _end, length);

System\Linq\Grouping.cs (1)

410Array.Copy(_elements, 0, array, arrayIndex, _count);

System\Linq\GroupBy.cs (1)

448Array.Copy(_elements, 0, array, arrayIndex, _count);

System\Dynamic\Utils\CollectionExtensions.cs (1)

40Array.Copy(array, 1, result, 0, result.Length);

System\Linq\Expressions\Compiler\StackSpiller.ChildRewriter.cs (1)

457Array.Copy(_expressions, first, clone, 0, count);

System\Runtime\CompilerServices\CallSite.cs (2)

253Array.Copy(rules, 0, temp, 1, rules.Length); 258Array.Copy(rules, 0, temp, 1, MaxRules - 1);

System\Runtime\CompilerServices\ReadOnlyCollectionBuilder.cs (4)

135Array.Copy(_items, index, _items, index + 1, _size - index); 154Array.Copy(_items, index + 1, _items, index, _size - index); 226public void CopyTo(T[] array, int arrayIndex) => Array.Copy(_items, 0, array, arrayIndex, _size); 358Array.Copy(_items, 0, array, index, _size);

System\Runtime\CompilerServices\RuleCache.cs (1)

101Array.Copy(rules, InsertPosition, newRules, InsertPosition + 1, newLength - InsertPosition - 1);

System\Linq\Parallel\Utils\GrowingArray.cs (1)

72Array.Copy(otherArray, 0, _array, _count, otherCount);

System\Linq\Parallel\Utils\Sorting.cs (1)

554Array.Copy(myValues, 0, mergedValues, leftCount, myValues.Length);

src\libraries\Common\src\System\Net\Http\aspnetcore\Http2\Hpack\DynamicTable.cs (2)

87Array.Copy(_buffer, _removeIndex, newBuffer, 0, headCount); 88Array.Copy(_buffer, 0, newBuffer, headCount, tailCount);

System\Net\Http\Headers\ObjectCollection.cs (2)

99Array.Copy(items, 0, array, arrayIndex, _size); 135Array.Copy(items, index + 1, items, index, _size - index);

System\Net\Http\SocketsHttpHandler\ConnectionPool\RequestQueue.cs (3)

99Array.Copy(_array, _head, newArray, 0, _size); 103Array.Copy(_array, _head, newArray, 0, _array.Length - _head); 104Array.Copy(_array, 0, newArray, _array.Length - _head, _tail);

src\libraries\System.Private.CoreLib\src\System\Array.cs (2)

351Copy(sourceArray, isourceIndex, destinationArray, idestinationIndex, ilength); 1050Copy(this, GetLowerBound(0), array!, index, Length);

src\libraries\System.Private.CoreLib\src\System\ArraySegment.cs (3)

109System.Array.Copy(_array!, _offset, destination, destinationIndex, _count); 122System.Array.Copy(_array!, _offset, destination._array!, destination._offset, _count); 165System.Array.Copy(_array!, _offset, array, 0, _count);

src\libraries\System.Private.CoreLib\src\System\Collections\ArrayList.cs (6)

255Array.Copy(_items, 0, array!, arrayIndex, _size); 270Array.Copy(_items, index, array!, arrayIndex, count); 392Array.Copy(_items, index, _items, index + 1, _size - index); 417Array.Copy(_items, index, _items, index + count, _size - index); 521Array.Copy(_items, index + 1, _items, index, _size - index); 542Array.Copy(_items, index + count, _items, index, _size - index);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\List.cs (11)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Queue.cs (10)

src\libraries\System.Private.CoreLib\src\System\DefaultBinder.cs (2)

357Array.Copy(args, paramArrayPos, (Array)objs[paramArrayPos], 0, args.Length - paramArrayPos); 442Array.Copy(args, paramArrayPos, (Array)objs[paramArrayPos], 0, args.Length - paramArrayPos);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\StackTrace.cs (1)

179Array.Copy(_stackFrames, _methodsToSkip, array, 0, _numOfFrames);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (1)

3455Array.Copy(args, 1, newargs, 0, args.Length - 1);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\ConcurrentSet.cs (1)

104Array.Copy(oldItems, lo, newItems, lo + 1, oldLength - lo);

src\libraries\System.Private.CoreLib\src\System\Globalization\CultureData.cs (1)

1689Array.Copy(calendars, 1, calendars, 2, 23 - 1 - 1);

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (1)

1416Array.Copy(patterns, 0, newPatterns, 1, patterns.Length);

src\libraries\System.Private.CoreLib\src\System\Reflection\Assembly.cs (1)

64Array.Copy(moduleTypes[i], 0, ret, current, length);

src\libraries\System.Private.CoreLib\src\System\Threading\AsyncLocal.cs (1)

430if (i != _keyValues.Length - 1) Array.Copy(_keyValues, i + 1, newValues, i, _keyValues.Length - i - 1);

src\libraries\System.Private.CoreLib\src\System\Threading\PortableThreadPool.WaitThread.cs (2)

331Array.Copy(_registeredWaits, removeAt + 1, _registeredWaits, removeAt, count - (removeAt + 1)); 337Array.Copy(_waitHandles, removeAt + 1, _waitHandles, removeAt, count - (removeAt + 1));

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (2)

79Array.Copy(oldQueues, 1, newQueues, 0, newQueues.Length); 88Array.Copy(oldQueues, pos + 1, newQueues, pos, newQueues.Length - pos);

src\System\Array.CoreCLR.cs (1)

780Array.Copy(@this, 0, array, index, @this.Length);

src\System\RuntimeType.CoreCLR.cs (1)

104Array.Copy(_items!, 0, array, index, _count);

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (2)

260Array.Copy(decomposedRight, 0, retVal, decomposedLeft.Length, decomposedRight.Length); 349Array.Copy(decomposedRight, 0, retVal, decomposedLeft.Length, decomposedRight.Length);

System\Xml\ArrayHelper.cs (2)

56Array.Copy(arrays![i], 0, newArray, offset, arrays[i].Length); 59Array.Copy(array, 0, newArray, offset, totalRead - offset);

System\Xml\XmlBaseReader.cs (2)

1452Array.Copy(_trailChars!, 0, chars, charCount, _trailCharCount); 1484Array.Copy(chars, charCount, _trailChars, 0, _trailCharCount);

System\Xml\XmlCanonicalWriter.cs (1)

732Array.Copy(_xmlnsAttributes, xmlnsAttributeIndex, _xmlnsAttributes, xmlnsAttributeIndex + 1, _xmlnsAttributeCount - xmlnsAttributeIndex);

System\Xml\BinaryXml\XmlBinaryReader.cs (4)

2011System.Array.Copy(data, mark, newdata, 0, cbKeep); 2016System.Array.Copy(data, mark, data, 0, cbKeep); 4140Array.Copy(_data, _tokDataPos, data, 0, _tokLen); 4320Array.Copy(_data, _tokDataPos, data, 0, _tokLen);

System\Xml\Core\XmlEventCache.cs (1)

571Array.Copy(buffer, index, bufferNew, 0, count);

System\Xml\Core\XmlTextReaderImpl.cs (2)

4502Array.Copy(_nodes, _index + 1, nameSortedAttributes, 0, _attrCount); 5007Array.Copy(_nodes, _index + 1, _attrDuplSortingArray, 0, _attrCount);

System\Xml\XPath\Internal\XPathMultyIterator.cs (1)

55Array.Copy(arr, firstNotEmpty, arr, firstNotEmpty + 1, pos - firstNotEmpty);

System\Xml\Xsl\IlGen\XmlILModule.cs (1)

139Array.Copy(paramTypes, 0, paramTypesNew, 1, paramTypes.Length);

System\Xml\Xsl\QIL\QilList.cs (2)

130Array.Copy(_members, index, _members, index + 1, _count - index); 146Array.Copy(_members, index + 1, _members, index, _count - index);

System\Xml\Xsl\Runtime\XmlQuerySequence.cs (1)

163Array.Copy(_items, 0, array, index, _size);

System\Reflection\Context\Projection\ProjectingType.cs (6)

248Array.Copy(methods, 0, members, i, methods.Length); i += methods.Length; 249Array.Copy(constructors, 0, members, i, constructors.Length); i += constructors.Length; 250Array.Copy(properties, 0, members, i, properties.Length); i += properties.Length; 251Array.Copy(events, 0, members, i, events.Length); i += events.Length; 252Array.Copy(fields, 0, members, i, fields.Length); i += fields.Length; 253Array.Copy(nestedTypes, 0, members, i, nestedTypes.Length); i += nestedTypes.Length;

System\Reflection\Metadata\BlobBuilder.cs (1)

290Array.Copy(chunk._buffer, bufferStart - chunkStart, result, bufferStart - start, bytesToCopy);

System\Reflection\Runtime\General\ListBuilder.cs (1)

65Array.Copy(_items!, 0, array, index, _count);

System\Reflection\TypeLoading\General\Ecma\MetadataTable.cs (1)

62Array.Copy(_table, skip, newArray, 0, newArray.Length);

System\Reflection\TypeLoading\General\Helpers.cs (1)

33Array.Copy(sourceArray: original, sourceIndex: 0, destinationArray: copy, destinationIndex: 0, length: original.Length);

System\Security\Cryptography\OidCollection.cs (1)

99Array.Copy(_oids, 0, array, index, _count);

System\Security\Cryptography\TripleDesImplementation.cs (1)

73Array.Copy(rgbKey, 0, newkey, 16, 8);

Internal\Cryptography\PkcsHelpers.cs (1)

107Array.Copy(arr, idx + 1, tmp, idx, tmp.Length - idx);

System\Security\Permissions\PrincipalPermission.cs (1)

194Array.Copy(operand._idArray, 0, idrolesArray, _idArray.Length, operand._idArray.Length);

System\Text\RegularExpressions\RegexRunner.cs (3)

457Array.Copy(runtrack, 0, newtrack, runtrack.Length, runtrack.Length); 470Array.Copy(runstack, 0, newstack, runstack.Length, runstack.Length); 482Array.Copy(runcrawl, 0, newcrawl, runcrawl.Length, runcrawl.Length);

src\libraries\Common\src\System\Collections\Generic\Deque.cs (2)

131Array.Copy(_array, _head, newArray, 0, _array.Length - _head); 132Array.Copy(_array, 0, newArray, _array.Length - _head, _tail);

src\libraries\Common\src\System\Collections\Generic\Deque.cs (2)

131Array.Copy(_array, _head, newArray, 0, _array.Length - _head); 132Array.Copy(_array, 0, newArray, _array.Length - _head, _tail);

Internal\ImmutableArray.cs (1)

73Array.Copy(_array, index + 1, newArray, index, _array.Length - index - 1);

System\Transactions\TransactionState.cs (1)

492Array.Copy(

Microsoft\Windows\Controls\Ribbon\NativeMethods.cs (1)

466Array.Copy(handleTypes, 0, newTypes, 0, handleTypeCount);

System\Windows\Forms\ActiveX\AxHost.AxPerPropertyBrowsingEnum.cs (1)

116Array.Copy(_names, 0, strings, 0, itemCount);

System\Windows\Forms\ComponentModel\COM2Interop\Com2IPerPropertyBrowsingHandler.Com2IPerPropertyBrowsingEnum.cs (3)

139Array.Copy(_names, i, _names, i + 1, itemCount); 140Array.Copy(valueItems, i, valueItems, i + 1, itemCount); 146Array.Copy(_names, 0, strings, 0, itemCount);

System\Windows\Forms\Controls\ListView\ListView.CheckedIndexCollection.cs (1)

222Array.Copy(IndicesArray, 0, dest, index, Count);

System\Windows\Forms\Controls\ListView\ListView.CheckedListViewItemCollection.cs (1)

324Array.Copy(ItemArray, 0, dest, index, Count);

System\Windows\Forms\Controls\ListView\ListView.ColumnHeaderCollection.cs (3)

373Array.Copy(_owner._columnHeaders!, 0, dest, index, Count); 547Array.Copy(_owner._columnHeaders, 0, newHeaders, 0, index); 552Array.Copy(_owner._columnHeaders, index + 1, newHeaders, index, columnCount - index);

System\Windows\Forms\Controls\ListView\ListView.cs (2)

3838Array.Copy(_columnHeaders!, 0, newHeaders, 0, columnCount); 3850Array.Copy(_columnHeaders, idx, _columnHeaders, idx + 1, columnCount - idx);

System\Windows\Forms\Controls\ListView\ListView.SelectedIndexCollection.cs (1)

298Array.Copy(IndicesArray, 0, dest, index, Count);

System\Windows\Forms\Controls\ListView\ListView.SelectedListViewItemCollection.cs (1)

327Array.Copy(SelectedItemArray, 0, dest, index, Count);

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.cs (2)

3496Array.Copy(components, 0, newComponents, 0, index); 3497Array.Copy(components, index + 1, newComponents, index, components.Length - index - 1);

System\Windows\Forms\Controls\PropertyGrid\PropertyGrid.PropertyTabCollection.cs (1)

100Array.Copy(

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\MergePropertyDescriptor.MultiMergeCollection.cs (1)

40Array.Copy(_items, 0, array, index, _items.Length);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\MultiPropertyDescriptorGridEntry.cs (1)

160Array.Copy(_objects, 0, copy, 0, _objects.Length);

System\Windows\Forms\Controls\PropertyGrid\PropertyGridInternal\PropertyGridView.cs (2)

3549Array.Copy(entries, 0, newEntries, 0, parentIndex + 1); 3552Array.Copy(

System\Windows\Forms\Controls\TabControl\TabControl.TabPageCollection.cs (1)

300Array.Copy(_owner.GetTabPages(), 0, dest, index, Count);

System\Windows\Forms\Controls\TreeView\TreeNode.cs (1)

1620Array.Copy(_children, 0, bigger, 0, _childCount);

System\Windows\Forms\Controls\TreeView\TreeNodeCollection.cs (1)

586Array.Copy(_owner._children, 0, dest, index, _owner._childCount);

System\Windows\Forms\DataBinding\Command.cs (1)

95Array.Copy(s_cmds, 0, newCmds, 0, icmd);

System\Windows\Forms\DataBinding\ListBindingConverter.cs (1)

150Array.Copy(ConstructorParamaterTypes, 0, ctorParams, 0, ctorParams.Length);

System\Windows\Forms\Design\EventsTab.cs (1)

127Array.Copy(attributes, 0, specifiedAttributesPlusContent, 0, attributes.Length);

System\Windows\Forms\Design\ColumnHeaderCollectionEditor.cs (1)

38Array.Copy(value, 0, colHeaders, 0, value.Length);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Utility\FrugalList.cs (4)

1339Array.Copy(_entries, 0, destEntries, 0, _entries.Length); 1365Array.Copy(_entries, index, _entries, index + 1, _count - index); 1400Array.Copy(_entries, index + 1, _entries, index, numToCopy); 1566Array.Copy(_sourceArray, start, _targetArray, _validItemCount, size);

System\Xaml\Parser\NodeStreamSorter.cs (3)

690Array.Copy(_sortingInfoArray, beginning, temp, 0, length1); 694Array.Copy(_sortingInfoArray, middle, _sortingInfoArray, beginning, length2); 698Array.Copy(temp, 0, _sortingInfoArray, beginning + length2, length1);

MS\Internal\Automation\Misc.cs (2)

85Array.Copy(a, 0, combined, pos, l); 126Array.Copy(a, 0, a2, 0, newLength);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\HandleCollector.cs (1)

45Array.Copy(handleTypes, 0, newTypes, 0, handleTypeCount);

src\Microsoft.DotNet.Wpf\src\Shared\MS\Win32\NativeMethodsCLR.cs (1)

2369Array.Copy(bytes, 0, buffer, offset, count);