mono/linux-packaging-mono
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported Upstream version 4.3.2.467

Browse Source 
Former-commit-id: 9c2cb47f45fa221e661ab616387c9cda183f283d
This commit is contained in:
Xamarin Public Jenkins
2016-02-22 11:00:01 -05:00
parent f302175246
commit f3e3aab35a
4097 changed files with 122406 additions and 82300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
external/referencesource/System.Core/System/Collections/Generic/HashSet.cs vendored
View File

@@ -56,11 +56,11 @@ namespace System.Collections.Generic {
[DebuggerDisplay("Count = {Count}")]
[SuppressMessage("Microsoft.Naming","CA1710:IdentifiersShouldHaveCorrectSuffix", Justification="By design")]
#if SILVERLIGHT
public class HashSet<T> : ICollection<T>, ISet<T>
public class HashSet<T> : ICollection<T>, ISet<T>, IReadOnlyCollection<T>
#else
[Serializable()]
[System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
public class HashSet<T> : ICollection<T>, ISerializable, IDeserializationCallback, ISet<T>
public class HashSet<T> : ICollection<T>, ISerializable, IDeserializationCallback, ISet<T>, IReadOnlyCollection<T>
#endif
{
@@ -303,7 +303,7 @@ namespace System.Collections.Generic {
// need to serialize version to avoid problems with serializing while enumerating
info.AddValue(VersionName, m_version);
#if FEATURE_RANDOMIZED_STRING_HASHING
#if FEATURE_RANDOMIZED_STRING_HASHING && !FEATURE_NETCORE
info.AddValue(ComparerName, HashHelpers.GetEqualityComparerForSerialization(m_comparer), typeof(IEqualityComparer<T>));
#else
info.AddValue(ComparerName, m_comparer, typeof(IEqualityComparer<T>));
@@ -962,14 +962,14 @@ namespace System.Collections.Generic {
int hashCode = InternalGetHashCode(value);
int bucket = hashCode % m_buckets.Length;
#if FEATURE_RANDOMIZED_STRING_HASHING
#if FEATURE_RANDOMIZED_STRING_HASHING && !FEATURE_NETCORE
int collisionCount = 0;
#endif
for (int i = m_buckets[hashCode % m_buckets.Length] - 1; i >= 0; i = m_slots[i].next) {
if (m_slots[i].hashCode == hashCode && m_comparer.Equals(m_slots[i].value, value)) {
return false;
}
#if FEATURE_RANDOMIZED_STRING_HASHING
#if FEATURE_RANDOMIZED_STRING_HASHING && !FEATURE_NETCORE
collisionCount++;
#endif
}
@@ -995,7 +995,7 @@ namespace System.Collections.Generic {
m_count++;
m_version++;
#if FEATURE_RANDOMIZED_STRING_HASHING
#if FEATURE_RANDOMIZED_STRING_HASHING && !FEATURE_NETCORE
if(collisionCount > HashHelpers.HashCollisionThreshold && HashHelpers.IsWellKnownEqualityComparer(m_comparer)) {
m_comparer = (IEqualityComparer<T>) HashHelpers.GetRandomizedEqualityComparer(m_comparer);
SetCapacity(m_buckets.Length, true);

4
external/referencesource/System.Core/System/Diagnostics/Eventing/Reader/Winmeta.cs vendored
View File

@@ -57,7 +57,7 @@ namespace System.Diagnostics.Eventing.Reader {
/// <summary>
/// EventOpcode
/// </summary>
[SuppressMessage("Microsoft.Naming","CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId="Opcode", Justification="[....]: Shipped public in 3.5, breaking change to fix now.")]
[SuppressMessage("Microsoft.Naming","CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId="Opcode", Justification="matell: Shipped public in 3.5, breaking change to fix now.")]
public enum StandardEventOpcode {
/// <summary>
/// An informational event
@@ -152,4 +152,4 @@ namespace System.Diagnostics.Eventing.Reader {
/// </summary>
EventLogClassic = 0x80000000000000
}
}
}

2
external/referencesource/System.Core/System/FuncAndAction.cs vendored
View File

@@ -17,4 +17,4 @@
// Action and Func types exist in mscorlib (up to 8 generic argument paremeters)
// and in System.Core.dll (See Microsoft\Scripting\Utils\[Action.cs | Function.cs])
// for 9-16 generic argument parameter versions.
// for 9-16 generic argument parameter versions.

2
external/referencesource/System.Core/System/IO/Enums.cs vendored
View File

@@ -18,7 +18,9 @@ using System.Text;
namespace System.IO {
#if !FEATURE_CORESYSTEM
[Serializable]
#endif
public enum HandleInheritability {
None = 0,
Inheritable = 1,

18
external/referencesource/System.Core/System/IO/MemoryMappedFiles/MemoryMappedFile.cs vendored
View File

@@ -181,6 +181,12 @@ namespace System.IO.MemoryMappedFiles {
return new MemoryMappedFile(handle, fileStream, false);
}
public static MemoryMappedFile CreateFromFile(FileStream fileStream, String mapName, Int64 capacity,
MemoryMappedFileAccess access,
HandleInheritability inheritability, bool leaveOpen) {
return CreateFromFile(fileStream, mapName, capacity, access, null, inheritability, leaveOpen);
}
[System.Security.SecurityCritical]
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
public static MemoryMappedFile CreateFromFile(FileStream fileStream, String mapName, Int64 capacity,
@@ -250,6 +256,12 @@ namespace System.IO.MemoryMappedFiles {
HandleInheritability.None);
}
public static MemoryMappedFile CreateNew(String mapName, Int64 capacity, MemoryMappedFileAccess access,
MemoryMappedFileOptions options,
HandleInheritability inheritability) {
return CreateNew(mapName, capacity, access, options, null, inheritability);
}
[System.Security.SecurityCritical]
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
public static MemoryMappedFile CreateNew(String mapName, Int64 capacity, MemoryMappedFileAccess access,
@@ -305,6 +317,12 @@ namespace System.IO.MemoryMappedFiles {
return CreateOrOpen(mapName, capacity, access, MemoryMappedFileOptions.None, null, HandleInheritability.None);
}
public static MemoryMappedFile CreateOrOpen(String mapName, Int64 capacity,
MemoryMappedFileAccess access, MemoryMappedFileOptions options,
HandleInheritability inheritability) {
return CreateOrOpen(mapName, capacity, access, options, null, inheritability);
}
[System.Security.SecurityCritical]
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)]
public static MemoryMappedFile CreateOrOpen(String mapName, Int64 capacity,

32
external/referencesource/System.Core/System/IO/MemoryMappedFiles/MemoryMappedView.cs vendored
View File

@@ -102,7 +102,7 @@ namespace System.IO.MemoryMappedFiles {
// if request is >= than total virtual, then MapViewOfFile will fail with meaningless error message
// "the parameter is incorrect"; this provides better error message in advance
UnsafeNativeMethods.MEMORYSTATUSEX memStatus = new UnsafeNativeMethods.MEMORYSTATUSEX();
bool result = UnsafeNativeMethods.GlobalMemoryStatusEx(memStatus);
bool result = UnsafeNativeMethods.GlobalMemoryStatusEx(ref memStatus);
ulong totalVirtual = memStatus.ullTotalVirtual;
if (nativeSize >= totalVirtual) {
throw new IOException(SR.GetString(SR.IO_NotEnoughMemory));
@@ -125,14 +125,32 @@ namespace System.IO.MemoryMappedFiles {
ulong viewSize = (ulong)viewInfo.RegionSize;
// allocate the pages if we were using the MemoryMappedFileOptions.DelayAllocatePages option
if ((viewInfo.State & UnsafeNativeMethods.MEM_RESERVE) != 0) {
IntPtr tempHandle = UnsafeNativeMethods.VirtualAlloc(viewHandle, (UIntPtr)viewSize, UnsafeNativeMethods.MEM_COMMIT,
// Allocate the pages if we were using the MemoryMappedFileOptions.DelayAllocatePages option
// OR check if the allocated view size is smaller than the expected native size
// If multiple overlapping views are created over the file mapping object, the pages in a given region
// could have different attributes(MEM_RESERVE OR MEM_COMMIT) as MapViewOfFile preserves coherence between
// views created on a mapping object backed by same file.
// In which case, the viewSize will be smaller than nativeSize required and viewState could be MEM_COMMIT
// but more pages may need to be committed in the region.
// This is because, VirtualQuery function(that internally invokes VirtualQueryEx function) returns the attributes
// and size of the region of pages with matching attributes starting from base address.
// VirtualQueryEx: http://msdn.microsoft.com/en-us/library/windows/desktop/aa366907(v=vs.85).aspx
if (((viewInfo.State & UnsafeNativeMethods.MEM_RESERVE) != 0) || (viewSize < nativeSize)) {
ulong allocSize = (nativeSize == 0) ? viewSize : nativeSize;
IntPtr tempHandle = UnsafeNativeMethods.VirtualAlloc(viewHandle, (UIntPtr)allocSize, UnsafeNativeMethods.MEM_COMMIT,
MemoryMappedFile.GetPageAccess(access));
int lastError = Marshal.GetLastWin32Error();
if (viewHandle.IsInvalid) {
__Error.WinIOError(lastError, String.Empty);
}
// The following is commented out for backward compatibility.
// Previously releases failed to check for this error so introducing this check
// could cause new/different exceptions in existing code paths.
// if (tempHandle == IntPtr.Zero) {
// __Error.WinIOError(lastError, String.Empty);
// }
// again query the view for its new size
viewInfo = new UnsafeNativeMethods.MEMORY_BASIC_INFORMATION();
UnsafeNativeMethods.VirtualQuery(viewHandle, ref viewInfo, (IntPtr)Marshal.SizeOf(viewInfo));
viewSize = (ulong)viewInfo.RegionSize;
}
// if the user specified DefaultSize as the size, we need to get the actual size

99
external/referencesource/System.Core/System/IO/Pipes/IOCancellationHelper.cs vendored Normal file
View File

@@ -0,0 +1,99 @@
//------------------------------------------------------------------------------
// <copyright company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Runtime.InteropServices;
using System.Security;
using System.Threading;
using UnsafeNativeMethods = Microsoft.Win32.UnsafeNativeMethods;
namespace System.IO.Pipes {
internal unsafe class IOCancellationHelper {
private CancellationToken _cancellationToken;
private CancellationTokenRegistration _cancellationRegistration;
[SecurityCritical]
private SafeHandle _handle;
[SecurityCritical]
private NativeOverlapped* _overlapped;
public IOCancellationHelper(CancellationToken cancellationToken) {
this._cancellationToken = cancellationToken;
}
/// <summary>
/// Marking that from this moment on
/// user can cancel operation using cancellationToken
/// </summary>
[SecurityCritical]
public void AllowCancellation(SafeHandle handle, NativeOverlapped* overlapped) {
Contract.Assert(handle != null, "Handle cannot be null");
Contract.Assert(!handle.IsInvalid, "Handle cannot be invalid");
Contract.Assert(overlapped != null, "Overlapped cannot be null");
Contract.Assert(this._handle == null && this._overlapped == null, "Cancellation is already allowed.");
if (!_cancellationToken.CanBeCanceled) {
return;
}
this._handle = handle;
this._overlapped = overlapped;
if (this._cancellationToken.IsCancellationRequested) {
this.Cancel();
}
else {
this._cancellationRegistration = this._cancellationToken.Register(Cancel);
}
}
/// <summary>
/// Marking that operation is completed and
/// from this moment cancellation is no longer possible.
/// This MUST happen before Overlapped is freed and Handle is disposed.
/// </summary>
[SecurityCritical]
public void SetOperationCompleted() {
if (this._overlapped != null) {
this._cancellationRegistration.Dispose();
this._handle = null;
this._overlapped = null;
}
}
public void ThrowIOOperationAborted() {
this._cancellationToken.ThrowIfCancellationRequested();
// If we didn't throw that means that this is unexpected abortion
__Error.OperationAborted();
}
/// <summary>
/// Cancellation is not guaranteed to succeed.
/// We ignore all errors here because operation could
/// succeed just before it was called or someone already
/// cancelled this operation without using token which should
/// be manually detected - when operation finishes we should
/// compare error code to ERROR_OPERATION_ABORTED and if cancellation
/// token was not used to cancel we will throw.
/// </summary>
[SecurityCritical]
private void Cancel() {
// Storing to locals to avoid data ----s
SafeHandle handle = this._handle;
NativeOverlapped* overlapped = this._overlapped;
if (handle != null && !handle.IsInvalid && overlapped != null) {
if (!UnsafeNativeMethods.CancelIoEx(handle, overlapped))
{
// This case should not have any consequences although
// it will be easier to debug if there exists any special case
// we are not aware of.
int errorCode = Marshal.GetLastWin32Error();
Debug.WriteLine("CancelIoEx finished with error code {0}.", errorCode);
}
SetOperationCompleted();
}
}
}
}

164
external/referencesource/System.Core/System/IO/Pipes/Pipe.cs vendored
View File

@@ -28,6 +28,7 @@ using System.Security.Permissions;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
@@ -623,6 +624,24 @@ namespace System.IO.Pipes {
}
}
public Task WaitForConnectionAsync(CancellationToken cancellationToken) {
if (cancellationToken.IsCancellationRequested) {
return Task.FromCancellation(cancellationToken);
}
if (!IsAsync) {
return Task.Factory.StartNew(WaitForConnection, cancellationToken);
}
// Avoiding allocation if the task cannot be cancelled
IOCancellationHelper cancellationHelper = cancellationToken.CanBeCanceled ? new IOCancellationHelper(cancellationToken) : null;
return Task.Factory.FromAsync(BeginWaitForConnection, EndWaitForConnection, cancellationHelper);
}
public Task WaitForConnectionAsync() {
return WaitForConnectionAsync(CancellationToken.None);
}
// Async version of WaitForConnection. See the comments above for more info.
[System.Security.SecurityCritical]
[HostProtection(ExternalThreading = true)]
@@ -640,6 +659,8 @@ namespace System.IO.Pipes {
asyncResult._userCallback = callback;
asyncResult._userStateObject = state;
IOCancellationHelper cancellationHelper = state as IOCancellationHelper;
// Create wait handle and store in async result
ManualResetEvent waitHandle = new ManualResetEvent(false);
asyncResult._waitHandle = waitHandle;
@@ -655,8 +676,12 @@ namespace System.IO.Pipes {
if (!UnsafeNativeMethods.ConnectNamedPipe(InternalHandle, intOverlapped)) {
int errorCode = Marshal.GetLastWin32Error();
if (errorCode == UnsafeNativeMethods.ERROR_IO_PENDING)
if (errorCode == UnsafeNativeMethods.ERROR_IO_PENDING) {
if (cancellationHelper != null) {
cancellationHelper.AllowCancellation(InternalHandle, intOverlapped);
}
return asyncResult;
}
// WaitForConnectionCallback will not be called becasue we completed synchronously.
// Either the pipe is already connected, or there was an error. Unpin and free the overlapped again.
@@ -676,6 +701,9 @@ namespace System.IO.Pipes {
__Error.WinIOError(errorCode, String.Empty);
}
// will set state to Connected when EndWait is called
if (cancellationHelper != null) {
cancellationHelper.AllowCancellation(InternalHandle, intOverlapped);
}
return asyncResult;
}
@@ -704,6 +732,11 @@ namespace System.IO.Pipes {
__Error.EndWaitForConnectionCalledTwice();
}
IOCancellationHelper cancellationHelper = afsar.AsyncState as IOCancellationHelper;
if (cancellationHelper != null) {
cancellationHelper.SetOperationCompleted();
}
// Obtain the WaitHandle, but don't use public property in case we
// delay initialize the manual reset event in the future.
WaitHandle wh = afsar._waitHandle;
@@ -728,6 +761,11 @@ namespace System.IO.Pipes {
// Now check for any error during the read.
if (afsar._errorCode != 0) {
if (afsar._errorCode == UnsafeNativeMethods.ERROR_OPERATION_ABORTED) {
if (cancellationHelper != null) {
cancellationHelper.ThrowIOOperationAborted();
}
}
__Error.WinIOError(afsar._errorCode, String.Empty);
}
@@ -939,6 +977,9 @@ namespace System.IO.Pipes {
[System.Security.Permissions.HostProtection(MayLeakOnAbort = true)]
public sealed class NamedPipeClientStream : PipeStream {
// Maximum interval in miliseconds between which cancellation is checked.
// Used by ConnectInternal. 50ms is fairly responsive time but really long time for processor.
private const int CancellationCheckIntervalInMilliseconds = 50;
private string m_normalizedPipePath;
private TokenImpersonationLevel m_impersonationLevel;
private PipeOptions m_pipeOptions;
@@ -1193,6 +1234,127 @@ namespace System.IO.Pipes {
throw new TimeoutException();
}
public Task ConnectAsync() {
// We cannot avoid creating lambda here by using Connect method
// unless we don't care about start time to be measured before the thread is started
return ConnectAsync(Timeout.Infinite, CancellationToken.None);
}
public Task ConnectAsync(int timeout) {
return ConnectAsync(timeout, CancellationToken.None);
}
public Task ConnectAsync(CancellationToken cancellationToken) {
return ConnectAsync(Timeout.Infinite, cancellationToken);
}
public Task ConnectAsync(int timeout, CancellationToken cancellationToken) {
CheckConnectOperationsClient();
if (timeout < 0 && timeout != Timeout.Infinite) {
throw new ArgumentOutOfRangeException("timeout", SR.GetString(SR.ArgumentOutOfRange_InvalidTimeout));
}
if (cancellationToken.IsCancellationRequested) {
return Task.FromCancellation(cancellationToken);
}
// We need to measure time here, not in the lambda
int startTime = Environment.TickCount;
return Task.Factory.StartNew(() => ConnectInternal(timeout, cancellationToken, startTime), cancellationToken);
}
// Waits for a pipe instance to become available. This method may return before WaitForConnection is called
// on the server end, but WaitForConnection will not return until we have returned. Any data writen to the
// pipe by us after we have connected but before the server has called WaitForConnection will be available
// to the server after it calls WaitForConnection.
[System.Security.SecuritySafeCritical]
private void ConnectInternal(int timeout, CancellationToken cancellationToken, int startTime) {
UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs = PipeStream.GetSecAttrs(m_inheritability);
int _pipeFlags = (int)m_pipeOptions;
if (m_impersonationLevel != TokenImpersonationLevel.None) {
_pipeFlags |= UnsafeNativeMethods.SECURITY_SQOS_PRESENT;
_pipeFlags |= (((int)m_impersonationLevel - 1) << 16);
}
// This is the main connection loop. It will loop until the timeout expires. Most of the
// time, we will be waiting in the WaitNamedPipe win32 blocking function; however, there are
// cases when we will need to loop: 1) The server is not created (WaitNamedPipe returns
// straight away in such cases), and 2) when another client connects to our server in between
// our WaitNamedPipe and CreateFile calls.
int elapsed = 0;
do {
// We want any other exception and and success to have priority over cancellation.
cancellationToken.ThrowIfCancellationRequested();
// Wait for pipe to become free (this will block unless the pipe does not exist).
int timeLeft = timeout - elapsed;
int waitTime;
if (cancellationToken.CanBeCanceled) {
waitTime = Math.Min(CancellationCheckIntervalInMilliseconds, timeLeft);
}
else {
waitTime = timeLeft;
}
if (!UnsafeNativeMethods.WaitNamedPipe(m_normalizedPipePath, waitTime)) {
int errorCode = Marshal.GetLastWin32Error();
// Server is not yet created so let's keep looping.
if (errorCode == UnsafeNativeMethods.ERROR_FILE_NOT_FOUND) {
continue;
}
// The timeout has expired.
if (errorCode == UnsafeNativeMethods.ERROR_SUCCESS) {
if (cancellationToken.CanBeCanceled) {
// It may not be real timeout and only checking for cancellation
// let the while condition check it and decide
continue;
}
else {
break;
}
}
__Error.WinIOError(errorCode, String.Empty);
}
// Pipe server should be free. Let's try to connect to it.
SafePipeHandle handle = UnsafeNativeMethods.CreateNamedPipeClient(m_normalizedPipePath,
m_access, // read and write access
0, // sharing: none
secAttrs, // security attributes
FileMode.Open, // open existing
_pipeFlags, // impersonation flags
UnsafeNativeMethods.NULL); // template file: null
if (handle.IsInvalid) {
int errorCode = Marshal.GetLastWin32Error();
// Handle the possible race condition of someone else connecting to the server
// between our calls to WaitNamedPipe & CreateFile.
if (errorCode == UnsafeNativeMethods.ERROR_PIPE_BUSY) {
continue;
}
__Error.WinIOError(errorCode, String.Empty);
}
// Success!
InitializeHandle(handle, false, (m_pipeOptions & PipeOptions.Asynchronous) != 0);
State = PipeState.Connected;
return;
}
while (timeout == Timeout.Infinite || (elapsed = unchecked(Environment.TickCount - startTime)) < timeout);
// BUGBUG: SerialPort does not use unchecked arithmetic when calculating elapsed times. This is needed
// because Environment.TickCount can overflow (though only every 49.7 days).
throw new TimeoutException();
}
public int NumberOfServerInstances {
[System.Security.SecurityCritical]
[SuppressMessage("Microsoft.Security","CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands", Justification="Security model of pipes: demand at creation but no subsequent demands")]

3
external/referencesource/System.Core/System/IO/__Error.cs vendored
View File

@@ -217,5 +217,8 @@ namespace System.IO {
throw new NotSupportedException(SR.GetString(SR.NotSupported_UnwritableStream));
}
internal static void OperationAborted() {
throw new IOException(SR.GetString(SR.IO_OperationAborted));
}
}
}

2
external/referencesource/System.Core/System/Linq/Enumerable.cs.REMOVED.git-id vendored
View File

@@ -1 +1 @@
d718d487e993e0ad7c2fa7a559117a327d48a95e
f062ca5e6394c3e981aa5bf8417cf029954e40a0

370
external/referencesource/System.Core/System/Linq/IQueryable.cs vendored
View File

File diff suppressed because it is too large Load Diff

4
external/referencesource/System.Core/System/Linq/Parallel/Enumerables/IParallelPartitionable.cs vendored
View File

@@ -7,7 +7,7 @@
//
// IParallelPartitionable.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -23,4 +23,4 @@ namespace System.Linq.Parallel
{
QueryOperatorEnumerator<T, int>[] GetPartitions(int partitionCount);
}
}
}

4
external/referencesource/System.Core/System/Linq/Parallel/Enumerables/QueryAggregationOptions.cs vendored
View File

@@ -7,7 +7,7 @@
//
// QueryAggregationOptions.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -27,4 +27,4 @@ namespace System.Linq.Parallel
Commutative = 2,
AssociativeCommutative = (Associative | Commutative) // For convenience.
}
}
}

4
external/referencesource/System.Core/System/Linq/Parallel/Merging/IMergeHelper.cs vendored
View File

@@ -7,7 +7,7 @@
//
// ImergeHelper.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -32,4 +32,4 @@ namespace System.Linq.Parallel
// Returns the merged output as an array.
TInputOutput[] GetResultsAsArray();
}
}
}

4
external/referencesource/System.Core/System/Linq/Parallel/Partitioning/IPartitionedStreamRecipient.cs vendored
View File

@@ -7,7 +7,7 @@
//
// IPartitionedStreamRecipient.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -22,4 +22,4 @@ namespace System.Linq.Parallel
{
void Receive<TKey>(PartitionedStream<TElement, TKey> partitionedStream);
}
}
}

4
external/referencesource/System.Core/System/Linq/Parallel/QueryOperators/OrdinalIndexState.cs vendored
View File

@@ -7,7 +7,7 @@
//
// OrdinalIndexState.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -23,4 +23,4 @@ namespace System.Linq.Parallel
Increasing = 2, // Indices of elements are increasing. Within each partition, elements are in the correct order.
Shuffled = 3, // Indices are of arbitrary type. Elements appear in an arbitrary order in each partition.
}
}
}

2
external/referencesource/System.Core/System/Linq/ParallelExecutionMode.cs vendored
View File

@@ -7,7 +7,7 @@
//
// ParallelQueryExecutionMode.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

4
external/referencesource/System.Core/System/Linq/ParallelMergeOptions.cs vendored
View File

@@ -7,7 +7,7 @@
//
// ParallelMergeOptions.cs
//
// <OWNER>[....]</OWNER>
// <OWNER>igoro</OWNER>
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -60,4 +60,4 @@ namespace System.Linq
/// </summary>
FullyBuffered = 3
}
}
}

10
external/referencesource/System.Core/System/Runtime/InteropServices/ComAwareEventInfo.cs vendored
View File

@@ -18,6 +18,9 @@ namespace System.Runtime.InteropServices {
#endregion
#region protected overrides
#if FEATURE_NETCORE
[System.Security.SecuritySafeCritical]
#endif//FEATURE_NETCORE
public override void AddEventHandler(object target, Delegate handler) {
if (Marshal.IsComObject(target)) {
// retrieve sourceIid and dispid
@@ -25,9 +28,11 @@ namespace System.Runtime.InteropServices {
int dispid;
GetDataForComInvocation(_innerEventInfo, out sourceIid, out dispid);
#if FEATURE_CAS_POLICY
// now validate the caller can call into native and redirect to ComEventHelpers.Combine
SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
perm.Demand();
#endif//FEATURE_CAS_POLICY
System.Runtime.InteropServices.ComEventsHelper.Combine(target, sourceIid, dispid, handler);
} else {
// we are dealing with a managed object - just add the delegate through reflection
@@ -35,6 +40,9 @@ namespace System.Runtime.InteropServices {
}
}
#if FEATURE_NETCORE
[System.Security.SecuritySafeCritical]
#endif//FEATURE_NETCORE
public override void RemoveEventHandler(object target, Delegate handler) {
if (Marshal.IsComObject(target)) {
// retrieve sourceIid and dispid
@@ -42,9 +50,11 @@ namespace System.Runtime.InteropServices {
int dispid;
GetDataForComInvocation(_innerEventInfo, out sourceIid, out dispid);
#if FEATURE_CAS_POLICY
// now validate the caller can call into native and redirect to ComEventHelpers.Combine
SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
perm.Demand();
#endif//FEATURE_CAS_POLICY
System.Runtime.InteropServices.ComEventsHelper.Remove(target, sourceIid, dispid, handler);
} else {
// we are dealing with a managed object - just add the delegate through relection

2
external/referencesource/System.Core/System/Security/Cryptography/Aes.cs vendored
View File

@@ -5,4 +5,4 @@
// ==--==
// moved to mscorlib.dll
[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Cryptography.Aes))]
[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Security.Cryptography.Aes))]

Some files were not shown because too many files have changed in this diff Show More